logo
An online, introductory, BSc-level course in numerical analysis, aimed at engineering students.

dr. R.P. Dwight <r.p.dwight@tudelft.nl>
Part of the BSc in Aerospace Engineering, TU Delft

This course is an introduction to numerical analysis, with a focus on the knowledge and skills useful for applications. The course is taught in an MSc at TU Delft, February-April (Quarter 3), but the course material is open to all.

Prerequisites: university-level a) calculus, and b) linear algebra. Exposure to real analysis would be an advantage, but is not necessary. In addition numerical exercises will be done in Python - some programming experience is required.

Topics: Numerical analysis is a broad heading, and we will cover a toolbox of methods for solving the problems of:

In each case we will look at the motivation for solving the problem numerically, the precise problem statement, various algorithms/methods, and the properties of the methods (especially under what circumstances they fail!). We do not cover solutions partial differential equations (PDEs), which are the subject of the following course AE2220-II Computational modelling. Neither do we consider the problems of classification, clustering, or sampling.

Structure: The course is structured in 6 modules, each module taking about one week, and tackling one of the above problems. For each module there are homework questions, old exams, and Python tutorials, in addition to the lecture material (videos) and course reader.

These lectures are the way you should approach the material first. Supporting material from the course reader is listed below each video. Attempt the corresponding homework questions, quiz questions, and Python tutorial after following the lectures:

Recordings of inverted classrooms:

The best way to encounter the material is via the videos - and they will cover everything needed to pass the course. Additionally the lecture notes are always available, and also contain all material needed to pass the course - sometimes in more detail than the lectures. For TU Delft students, these notes can be ordered printed and bound from readers.tudelft.nl. The 6 Modules of the course correspond to chapters in the reader as follows:

These are intended as a way of challenging yourself that you understand the material. The homework questions are generally more simple and mechanical, while the exam questions demand a deeper understanding. Answers are provided, but as always, struggling with a question without looking at the answer is often a valuable (if uncomfortable) experience. Example quizzes - 1h30 mins each:

4b. Worked solutions

These are worked solutions for the homework questions, as well as the Quizzes of 2013, 2015 & 2016. These were written entirely by an ex-student Sam van Elsloo, but I've checked everything personally and they are now an official part of the course material. Please let me know (as with all course material), if you find any errors.

For each Module an IPython notebook is available. These can be worked through on your own laptops if you have a complete scientific Python install (numpy, scipy, ipython, etc.) - Anaconda with Python 3.6 is recommended. For those with no programming experience, try following a couple of lessons at Codecademy. The notebooks do not require advanced Python knowledge.

To ensure access for everyone I've setup a server at: https://ipython.lr.tudelft.nl:8888. The port number is important! Your username is your TU Delft NetID, and your password will appear in Brightspace GradeCenter. The notebooks will appear on this server. Moreover, on this server you can run the notebooks from within any browser, make modifications, plots, etc. Please just bear in mind that your code is not running locally, but on the server, which has limited capacity. So please don't perform long-running computations. And anyone doing e.g. BitCoin mining will be kicked off quickly!

Notebook files:

5b. IPython Assignments (bonus points)

There are two programming assignments for this course, A and B, available on the IPython server and here. Each assignment is worth 0.25 bonus points (added to your grade from the exams) - and requires you to carefully do a programming exercise. To login to the server and see the assignment: Some important notes: The deadlines will be annouced during the course, and results will be announced shortly after.

The course has two slots per week in Q3, mostly Tuesdays 13:45-15:30 and Fridays 15:45-17:30 - but varying week-to-week. One slot per week will be used for:

The course is assessed with 3 partial exams, in Weeks 3.4, 3.6 and 3.9. Please check Osiris for the dates and times already - you'll need to be available for all three partial exams to get credit for the course. These exams all require registration in Osiris, and since the first one is week 3.4 the deadline is soon after the start of the course.

The exam questions will be the same style as in previous years - i.e. 10 multiple choice questions in 1.5 hours. The exams will be preferentually held on-site, if not possible they will be remote using Mobius with remote proctoring.

There are three fundamental study activities which can help gain understanding of the - sometimes abstract - ideas in this course:

  1. Teach someone else;
  2. Devise variations of the method and hypothetical situations; and
  3. Explore connections between parts of the course.
Points 2. and 3. area regular source of challenging exam questions. For Module 1 - Root-finding here are some examples of each point:
  1. In your own words (without reference to the reader or lectures), communicate to someone a basic idea or definition. For example:
    1. What is a root?
    2. What is a fixed-point iteration?
    3. What does "convergence" mean?
    4. Why are we interested in convergent methods only?
    5. What is the significance of i?
    In each case be specific and detailed.
  2. Create variations of methods/problems, ask "What if...?" questions. For example:
    1. What happens if we divide an interval into two unequal pieces in recursive bisection? How is the convergence rate affected?
    2. What happens if we apply a fixed-point iteration to a linear function?
    3. Or Newton to a linear function?
    4. Could we generalize Newton's method, by using a quadratic approximation of f(x) at x_0, to get even better convergence?
    5. If we want a very low error (e.g. \(10^{-16}\)) which root finding algorithm should we use? I.e. which will give an answer in the fewest evaluations of f?
    6. Can we combine two or more of the methods learnt to get an algorithm that has nicer properties than any of them individually?
    7. What if we need to solve the problem: min f(x)? Can we do this with a root-finding method? What requirements must we place on f?
    8. What kind of problems are going to occur when using these methods with floating-point arithmetic?
    Use the methods of analysis learnt at the lectures to stuudy these questions.
  3. Find connections between course compenents. Understand one idea in terms of another. For example:
    1. How does Newton's method relate to the Taylor expansion?
    2. How does Newton relate to fixed-point iterations in general?
    3. In what way is the number of iterations N, in root-finding methods, similar to the number of intervals N, in the integration method discussed in the lectures? In what ways are they different?
    Does this insight simplify your conceptual model of the methods?

dr. R. Dwight ≤r.p.dwight@tudelft.nl≥ - Jan 2024