- Section 4.4 homework has been graded.
- Some of your octave code: Octave-online (alternate link).
- A word on maxits....
- Recursion is a marvelous thing, but you have to beware of infinite loops -- that's why you need a stopper.
- Usually I count down -- I ask the user for the
maxits, and then, each time I recurse, I cut
the number of maxits by one. When I hit zero,
I'm done, and I race back up the tree.
You can just as easily count up, of course; but you want to give the user the ability to control the number.
- My Mathematica code, and a pdf of that.
- I've evaluated your sigmacs, and the measure of their success was
whether I was able to remove money from your bank
accounts. Sorry if I emptied them by mistake -- completely in
error, I assure you....
Honestly though:
Let's go through these and see if there are any particular remarks you'd like to make. I'll point out a few things.
- Danny got a little ambitious: "With this idea in mind I
proceeded to make everyone's signatures by reverse engineering
the points from the svg file." (Did you succeed, Danny?)
- Danny's
Report
Danny considered a constrained problem: how to make a single Bezier cubic form a circle. It's not easy ("might fool a toddler...").
Danny also put ChatGPT to use in trying to solve this problem.
- Target signature
- Danny's D
- Danny's
Report
- Stefanie ("Stef" -- fair enough, says "Andy"):
- Stefanie's Report
- Target signature
- Stefanie used Mathematica to lend a hand: sigmac.nb
but struggled to get the "weird little wiggles" just right!
- Madison (who bravely forged ahead with "Madison"!):
- Madi's
Report (I highly recommend a read -- very well constructed.)
An important highlight is a description of the tedium involved. But the final results, wow!
Note the handwork (and hard work, and tedium) of transcribing the points from the signature.
- Target signature
- Madi's
Report (I highly recommend a read -- very well constructed.)
- Yimin (perhaps wisely!) didn't trust me to have his signature:) But he did provide this Desmos link.
- Danny got a little ambitious: "With this idea in mind I
proceeded to make everyone's signatures by reverse engineering
the points from the svg file." (Did you succeed, Danny?)
- Wednesday is project day. You'll each have about 15 minutes.
- Nice presentation on Friday, Danny! Sorry you all couldn't be there, but
Danny did a great job.
- I've been asked to promote The Norse Marketplace event, happening tomorrow starting at 11:30.
- We explored Runge-Kutta methods: replacing the computation of
derivatives by linear combinations of carefully chosen function
values. Our author approached the derivation of the RK methods
in an unusual way: from the standpoint of integration formulas.
We end up with an implicit formula for \(y\) -- buried in that integrand -- which allowed us to approximate points along the curve: \[ y(t_{1})=y(t_{0})+\int_{t_{0}}^{t_{1}}f(t,y)\,dt \] Each integration method produces a different estimate for that integral, and hence provides a different method for estimating the solution of the ODE.
Some methods leave us in a quandary as to how to replace a value (e.g. the derivation of Simpson's).
- There was no real quandary with the Left-Rectangle Rule, which led
to the "Euler" method:
\[
y_{i+1}=y_{i}+h f(t_{i},y_{i})
\]
We know \(f\), and we know \(y_0\) (we study so called "initial value problems", IVPs, where we know the starting value) -- putting those together we can estimate \(y_1\); now do it again!
- Beyond the "Euler" method, however, these methods lead to an
implicit equation for \(y(t_{i+1})\) where we have to do a
little more work, e.g. for the trapezoidal method:
\[
y_{i+1}=y_{i}+\frac{h}{2}\left[f(t_{i},y_{i})+f(t_{i+1},y_{i+1})\right].
\]
so we need to use some sort of trickery, and it seems
reasonable to use Euler's approximation as some sort of
application of Occam's
Razor ("The simplest explanation is usually the best one."):
\[ y_{i+1}=y_{i}+\frac{h}{2}\left[f(t_{i},y_{i})+f(t_{i+1}, y_{i}+h \cdot f(t_{i},y_{i}))\right]. \]
- And for the "Simpson" method we really struggle to figure out how
to approximate those intervening values of \(y\):
\[
y_{i+1}=y_{i}+\frac{h}{6}\left[f(t_{i},y_{i})+4f(t_{i+1/2},y_{i+1/2})+f(t_{i+1},y_{i+1})\right].
\]
Our author takes a crack at it, but admits that the first crack is not the best crack. Then, in a crumpet in the next section (which covers the error analysis of these methods), illustrates how RK4 is obtained from the typical "undetermined coefficents" approach by clever matching of Taylor series.
- RK4 is the typical end goal of most numerical analysis courses at
the undergraduate level (although we would have liked to push
it a little further, with an adaptive scheme):
\[
y_{i+1}=y_{i}+\frac{h}{6}\left[f(t_{i},y_{i})+2f(t_{i+1/2},y_{i+1/2})+2f(t_{i+1/2},y_{i+1/2})+f(t_{i+1},y_{i+1})\right].
\]
\[ \begin{eqnarray*} k_{1} & = & f(t_{i},y_{i})\\ k_{2} & = & f\left(t_{i}+\frac{h}{2},y_{i}+\frac{h}{2}k_{1}\right)\\ k_{3} & = & f\left(t_{i}+\frac{h}{2},y_{i}+\frac{h}{2}k_{2}\right)\\ k_{4} & = & f(t_{i+1},y_{i}+hk_{3})\\ y_{i+1} & = & y_{i}+\frac{h}{6}\left[k_{1}+2k_{2}+2k_{3}+k_{4}\right]. \end{eqnarray*} \]
We have split the middle term into two pieces, and essentially use two different slopes to approximate its value (creating a new estimate from two others).
- Then we checked out each of these schemes using some Mathematica
code for the example tables (pdf).
- We noted in particular how we can treat higher order ODEs as
systems using these same methods which we derived for
first-order equations, by introducing extra variables.
- About the exam (which is a week from today):
- Your comprehensive final exam is Monday, April 29th, 2:30-4:30.
- The take-home portion will be the homework problems from
sections 6.2 and 6.3. You're welcome to ask me
questions, but otherwise please do those on your
own. As usual, it will be worth 30% of your total.
The take-home part will be due on Wednesday, May 1st, at Midnight (I can't wait much further, because I'll be doing a lot of grading, and can't get backed up). I'm planning on grading those on Thursday.
- Coverage for in-class:
- 1/3 over new material (ODEs)
- 1/3 over exam 2 material
- 1/3 over exam 1 material
You might also look over the homeworks for each section.
- Notice that, in contrast to previous exams, there will be
some numerical ODE questions similar to those covered
on the take-home part.
- You're allowed your notes, but you may want to pare them
down onto a sheet or two (to avoid paper-thrashing),
and keep the others in reserve in case you really need
to dig.
Danny has some notes that he's worked up (and perhaps continues to work up!), which he has indicated he is willing to share.
- Your comprehensive final exam is Monday, April 29th, 2:30-4:30.
- Themes of the course:
- All models are wrong; some models are useful.
There are those who think that mathematics is great because "there's always a right answer." Well, phooey!:)
- We're going to give you the wrong answer; but hopefully
we'll be able to estimate, model, and bound the error.
It ain't lyin', but it's the best we can do!
- Polynomials are really, really useful (in spite of the
fact that they are the bunny rabbits of the function
zoo!):
- Taylor polynomials especially.
- Linear polynomials are especially useful: and we used them
to good effect in several different ways:
- Newton and Secant methods (finding methods that allow us to avoid derivatives)
- Lagrange interpolating basis functions
- Generalizing some of those methods into tangent
parabolas, and tangent cubics, etc:
- Muller's method
- Lagrange and Newton interpolating polynomials
- differentiation and integration methods (getting polynomials right)
- Taylor methods in ODEs
- Taylor polynomials especially.
- Whenever you have two estimates, you have a third: an average.
- And if you understand the structure of the errors, you
can be very clever about your averages (e.g. Simpson's
rule).
- In a similar vein, we can use a sequence of estimates to generate a better sequence of estimates, by knowing their "tendency" (e.g. Aitken's and Steffensen's methods, accelerating convergence).
- And if you understand the structure of the errors, you
can be very clever about your averages (e.g. Simpson's
rule).
- Recursion is very powerful:
- But not always the best way to compute, and can be
dangerous). It's often an easy way to
start, but then optimization is possible.
We saw that on this homework 4.4.
- Fixed point iteration almost seems like magic, and
there are a million fixed point iteration functions you
can choose from. But a little analysis allows us to see
that Newton's choice is best.
- But not always the best way to compute, and can be
dangerous). It's often an easy way to
start, but then optimization is possible.
- When you can't balance errors, at least bound them. (I'm
still not seeing quite enough absolute values. And I
hope that you're getting the idea of \(\xi\)....)
- Creating methods that adapt to their targets is not only
wise, but it's fun! (E.g. adaptive quadrature)
- Error analysis was the key to creating the adaptive schemes.
- Sometimes a method created for one thing (e.g. adaptive integration) can be used for another (adaptive plotting!). Reuse stuff if you can!
- All models are wrong; some models are useful.
- What questions do you have?
- Our Textbook: Tea Time Numerical Analysis (Leon Q. Brin)
- Some old lisp routines illustrating the connection between
adaptive quadrature and adaptive plotting:
- Here's my lisp version of the plotting routine, then turned into an adaptive quadrature scheme:
-
Here's a similar lisp version of a local adaptive quadrature
routine, which is then turned into an adaptive plotting
scheme:
It's not quite what you're asked to do in this algorithm, however, since you're to keep track of the errors, and keep poking at the largest:
- Here's the global adaptive quadrature routine, which is then turned into an adaptive plotting scheme:
- A paper my dad and I wrote about integration techniques: including lots of details!:)
- Some notes
- An interesting
alternative derivation technique. Here, for example, is a
four-point forward difference formula for the derivative, obtained
using the Newton polynomial interpolator (notice, however, that the \(x\)
values in the numerator should actually be \(y\) values -- function values):
But the idea is really swell, and I am delighted by this method!
- An example of cubic splines: how do we intepolate two
points and their slopes using a cubic? We can derive the so-called
"Hermite spline" as a variant of Lagrange interpolation, featuring "get
out of the way" functions!
Here's another picture of how we might build one of these.
- Homework solutions:
- 1.1 (Mathematica)
- 1.2 (Mathematica)
- 1.3 (Mathematica)
- 2.1 (Mathematica)
- 2.2 (Mathematica)
- 2.3 (Mathematica)
- 2.4 (Mathematica)
- 3.2 (Mathematica)
- 3.3 (Mathematica)
- 4.1 (Mathematica)
- My Mathematica code for Section 2.6. Muller code, too.
- My Octave Project for 2.6 homework.
- Octave project for 2.5
- Divided Differences. I use these in my Muller code, and they will prove useful when it comes to interpolating polynomials.
- Author's octave code for these complex fractal convergence diagrams
- Newton's method in Mathematica
- fixed point with Aitken's acceleration in Mathematica
- Some nice notes (and code) snippets on fixed point iteration, including these acceleration techniques.
- fixed point in Mathematica
- Check out how my bisection works, and how it is applied to arcsine....
- Various sins....