Topic outline

  • General

    Collapse all Expand all

    An image of Grace Hopper, one of the pioneers of compiler languages, with old fashioned computers.

    An image of Grace Hopper, who pioneered the invention of compiler languages (like python), that allow us to tell the computer what to do in English words that are then translated into machine code. 

    MODULE DESCRIPTION:

    Lecturer: Dr Katy Clough only started coding late in her masters degree but is now one of the main developers of an open source code for numerical gravity simulations (http://www.grchombo.org), and deputy chair of the UK panel for awarding high performance computing time to astronomers and cosmologists (https://dirac.ac.uk).

    Prerequisites: Before taking this module you must take at least 1 module from level 6 matching MTH. Some experience with python or similar coding languages will be an advantage but will not be assumed - in fact I welcome and encourage those without a coding background to attend and learn this important skill. 

    Description: This module introduces a selection of numerical methods for solving applied mathematical problems. One of the most fascinating aspects of physical theories is the fact that highly complex behaviour can arise from the repeated application of simple rules - consider for example the motion of bodies under gravity, which combine to give us the rich structure of our Universe. Such systems are the focus of much current research, and whilst they are too complex for an analytic approach, their numerical solution is (at least in principle) straightforward. The aim of the course is to introduce students to a selection of computational algorithms that are used to solve problems in applied mathematics, and to provide them with practical skills in software development that will be useful in many fields both within and outside of academic work. The module uses python as the main coding language. 
    Credits: 15.0, Level: 7.
    See the "Syllabus and learning outcomes" tab for further information.

    Please watch the welcome video below for my personal introduction to the module!

    Assessment:
    • Item 1: 20% Coursework 1 (released start of Week 4 and due end of Week 9)
    • Item 2: 80% Coursework 2 (released start of Week 10 and due by 19 January 2024)
    See the "Assessment and coursework" tab for further details.

    Timetable:

    • Lab/exercise class - Thursday 14:00-16:00 (Weeks 1-12) Location: Maths: MB-302 PC lab
    • Lectures - Monday 10:00-12:00 (Weeks 2-12) Location: Graduate Ctr: GC114
    • Learning support hour - Thursday 13:00-14:00 (Weeks 2-12) - in the Learning Cafe - the Social Hub (MB-B11)  and other times by arrangement


    Note that in Week 1 there will be no lecture, only a lab to help you get set up with GitHub and the python coding environment that you will use. There is a walkthrough video that you can watch to help you with this.

    In Week 7 I will introduce techniques for parallelising code, which will not be a required skill to complete the coursework but is extremely useful and interesting. Therefore whilst there will be a lecture and lab this week, if you cannot make it this should not affect your grade. 

    • Welcome video QMplus Media Video
    • Announcements Forum
    • Student forum

      Forum Description: This forum is available for everyone to post messages to. Students can raise questions or discuss issues related to the module. Students are encouraged to post to this forum and it will be checked daily by the module leaders. Students should feel free to reply to other students if they are able to.

  • Where to get help

    There will undoubtedly be times during the term when you get stuck with some concepts - this is normal. 

    Email is usually not the best way to ask questions - you are strongly encouraged to use the student forum to post course or code questions.

    For more in-depth questions, the best way to get help is to raise questions during the in-person lab, or during or after the lectures. You are also welcome to come and ask questions during my learning support hour every Thursday 1pm-2pm at the Learning Cafe, or at other times that we can agree between us.

    Policy on use of ChatGPT and stackexchange:

    You can ask ChatGPT for help with the weekly exercises. Actual software developers use it, so I see no point in asking you not to. At some level, being able to program well, especially in a scientific research context, is mainly being good at googling for solutions. The source of much of my knowledge has been https://stackexchange.com, and you should learn to use these resources to support your programming.

    However, you will learn nothing from blind copying, and it can be dangerous, so always engage your brain before using other people's (or AI's) code. A common lore in programming is that there are people who answer stackexchange posts suggesting that you type "rm -r *". This will remove all the folders and files at your location (recursively) with no hope of getting them back (although if you use git as we do in this course you are somewhat protected from the consequences). 

    Only copy code if you can understand exactly what it is doing, this way it will support your learning, not replace it.

    Note that the coursework will have a more specific policy on use of ChatGPT, including the requirement to reference it where used. Further details will be provided when the coursework is released.

  • Week 1 - Setup lab and questionnaire

    In this first week the goal is to get yourself set up with the python environment that we will use, and familiarise yourself with GitHub.

    Before doing anything, please complete the Background Questionnaire below.

    You should then follow the instructions in the wiki here: https://github.com/KAClough/TopicsInSciComp/wiki, or watch my Week 1 Walkthrough Video below.

    The lab material is kept here: https://github.com/KAClough/TopicsInSciComp, and for week 1 there are just some example notebooks to look at and practise running - they can also be found below but you should try to access them via GitHub in the instructions if possible.

    Once you have done this, you can test that you have retained the key points by completing the Week 1 MCQ Test below.



  • Week 2

    This week we will discuss best practise for coding:

    1. Good grammar for good code - types, variables, assignment, functions, loops, conditionals.
    2. Python libraries - NumPy, SciPy and Matplotlib as examples
    3. Good coding practise - version control, defensive programming, comments


    I will upload the lecture notes after the lecture on Monday.

    The Jupyter notebook for the tutorial can be found below and on GitHub (I will explain in the lecture about how to update your fork to get it via GitHub).

    I will upload the solutions to the exercises the following week.

    There is also the Week 2 MCQ Test below to test your knowledge (as usual it does not count towards your grade).

  • Week 3

    This week we will discuss the following topics:

    1. Classes and object oriented coding in python
    2. The integration of simple ordinary differential equations using numerical integration and the solve_ivp() function in python


    I will upload the lecture notes after the lecture on Monday.

    The Jupyter notebook for the tutorial can be found below and on GitHub.

    As agreed with you last week in our tutorial I will upload the solutions to the exercises at the start of the tutorial. If you know python quite well, try not to look at them until you are done! If python is very new to you then looking at the solutions just to see how to start make help speed up your learning. You are in charge of your learning, so do what works best for you!

    A Week 3 MCQ Test can be found below.

  • Week 4

    This week we will revise and deepen our understanding of the following topics:

    1. Classes and object oriented coding in python - protecting attributes and passing functions to functions
    2. The explicit integration of simple ordinary differential equations - higher order ODEs, stability, midpoint and RK4 methods.


    I will upload the lecture notes after the lecture on Monday.

    I will also announce the first coursework, worth 20%, on Monday during the lecture, and discuss the physical background to the problem. This coursework is due by 24 November at 5pm.

    The Jupyter notebook for the tutorial can be found below and on GitHub. I will upload the solutions just before the tutorial class.

    The Week 4 MCQ test is below.

  • Week 5

    This week we will cover the following topics

    1. Implicit integration of linear ODEs
    2. The use of python for linear algebra, including sympy and numpy functions and classes

    The lecture notes are below, and this week Q-Review worked! So you can watch the lecture there.

    Please also complete the Early Feedback Questionnaire in the new tab above. It is anonymous and will help me to improve the class for you. All questions are optional.

    The Jupyter notebook for the tutorial can be found below and on GitHub. I will upload the solutions just before the tutorial class.

    The Week 5 MCQ test is also below.

  • Week 6

    This week we will cover the following topics

    1. Implicit integration of non linear ODEs
    2. Solving Ax=b without inverting A
    3. Problems with problems! Ill posed and ill conditioned problems.

    The lecture notes are below, and the lecture should be available on Q-Review after Monday morning.

    The Jupyter notebook for the tutorial can be found below and on GitHub. I will upload the solutions just before the tutorial class.

    The Week 6 MCQ test is also below.

  • Week 7 - optional lectures on parallelisation

    This week we will have an optional lecture on parallelisation on Monday. This material will not be required for the coursework.

    The lecture notes will be given below, and the lecture should be available on Q-Review after Monday morning.

    There will be a tutorial, but I will not set new exercises. Please use the time to start work on your coursework, catch up with previous exercises and optionally (only if you are up to date on everything else) try out the parallelisation we discussed in the lecture. I will be there to answer any questions you have.


  • Week 8

    This week we will cover the following topics

    1. Interpolation of functions
    2. Integation of functions

    The lecture notes are below, and the lecture should be available on Q-Review after Monday morning.

    The Jupyter notebook for the tutorial can be found below and on GitHub. I will upload the solutions just before the tutorial class.

    The Week 8 MCQ test is below!

  • Week 9

    This week we will cover the following topics

    1. Differentiation of functions using finite difference and pseudospectral methods
    2. The heat equation

    The lecture notes are below, and the lecture should be available on Q-Review after Monday morning.

    The Jupyter notebook for the tutorial can be found below and on GitHub. I will upload the solutions just before the tutorial class.

    The Week 9 MCQ test is below!

  • Week 10

    This week we will cover the following topics

    1. Revision of PDE classification
    2. Well posedness
    3. Stability and the CFL condition
    4. The wave equation

    The lecture notes are below, and the lecture should be available on Q-Review after Monday morning.

    The Jupyter notebook for the tutorial can be found below and on GitHub. I will upload the solutions just before the tutorial class.

    The Week 10 MCQ test is below.

  • Week11

    This week we will cover the following topics

    1. PDE classification - higher dimensional cases
    2. Implicit methods for PDE solution - the trapezium rule
    3. Solving elliptic equations as boundary value problems using relaxation
    4. Non linear Poisson equation as an example

    The lecture notes will appear below, and the lecture should be available on Q-Review after Monday morning.

    The Jupyter notebook for the tutorial will be found below and on GitHub. I will upload the solutions just before the tutorial class.

    The Week 11 MCQ test is below.

  • Week 12

    This week we will revise the topics we have covered, go through the first coursework, and complete any outstanding tutorials.

    I strongly suggest that you use the tutorial this week to start the coursework and ask me any questions about aspects you are unsure of.

  • Assessment and coursework

    The assessment of the module “Topics in Scientific Computing” is based on two courseworks. The first coursework contributes 20% of the final mark, while the second coursework accounts for the remaining 80%. 

    The weekly MCQ quizzes are not compulsory and not assessed, but are an excellent way of checking if you master the minimum learning outcomes for the course. However, the bulk of your learning will take place while you practice your coding skills in the lab and exercises.

    For the two courseworks you will need to upload a Jupyter Notebook which addresses an extended programming question and includes some short texts in the markdown format. The project will assess your coding and communication skills - in particular it will not only check that your solution works, but also that it is readable, clear and commented as appropriate.

    The first coursework will be uploaded at the start of Week 4 and will be due by the end of Week 9, while the second coursework will be uploaded at the start of Week 10 and will be due by the end of the January exam period (19 January 2024).

    When the courseworks are uploaded I will give more concrete information on the requirements, marking scheme, and restrictions on communication and collaboration with others, and use of ChatGPT resources. 

    Please note that previous year assessments for this course should not be considered as examples of the coursework this year - they will not be exactly the same format due to changes in the focus of the course and in particular changes to the coding language used. 

    If you do not pass the coursework on the first attempt, you will be reassessed based on another attempt at a coursework equivalent to the second only. Again further details will be provided if required - I hope that all students will be able to pass on the first attempt - should you have any concerns about your ability to do so please get in contact with me as early as possible.

  • Syllabus

    Learning outcomes
    • LO1 - Students should understand the concepts of scientific computing in an applied way – any numerical calculation required of them should demonstrate understanding of a concept, and not just test abstract mathematical skill.
    • LO2 - Students should be able to use computational algebra or implement in computational code numerical methods to solve some standard problems in mathematics (such as integration, differentiation and interpolation).
    • LO3 - Students should be able to critically review the methods, be aware of their limitations, and discuss them in the context of their use in research.
    • LO4 - Students should develop their skills as self regulated learners and researchers who can seek out, critically assess, and apply information in the right context, and work as part of a team.


    See the more specific learning outcomes given week by week below.

    Specific topics covered by week (may change according to time and interest of students):

    1. Basics of scientific programming

    Virtual environments, use of git for versioning of software and collaborative work, python, numpy, scipy and sagemath.

    2. Basics of scientific programming in python

    Types, variables, arithmetic operations, assignments, functions, plotting, loops and conditionals, numpy arrays, scipy and  Matplotlib as examples of python libraries, version control, defensive programming, use of comments.

    3. Object oriented programming (OOP) and numerical solutions of  simple ordinary differential equations

    Basic OOP concepts - classes, attributes, methods, inheritance.

    Revision of ODEs. Numerical integration, Euler's method for explicit integration of first order ordinary differential equations, python function solve_ivp(), logistic equation and predator-prey equations as examples.

    4. Numerical solutions of  ordinary differential equations - explicit methods and higher order equations

    Explicit schemes e.g. Runge-Kutta methods, solving 2nd order (and higher) ODEs - damped harmonic oscillator and van der Pol oscillator as examples.

    5. Numerical solutions to ordinary differential equations - implicit methods and linear algebra

    Implicit schemes, and why to use them, stiffness of systems, linear algebra using numpy and sympy. Backward Euler method.

    6.  Solving the linear system Ax = b, well conditioned and well posed problems 

    Implicit schemes for non-linear ODEs. Solving Ax = b using python methods, and via iterative schemes. Numerical issues, norms, condition numbers, ill conditioned problems, ill posed problems, and how to identify them. 

    7. Parallelisation of numerical schemes (Week 7 - optional)

    Structure of computers and supercomputers, parallelisation principles, MPI versus multithreading/shared memory, use of MPI4py in python.

    8. Numerical interpolation and integration of functions

    Interpolation of functions - Lagrange polynomials, Hermite polynomials, use of Gauss Lobato nodes for Chebyshev polynomials. Numerical integration - trapezoid, Hermite and Simpsons rules, composite methods, Gaussian quadrature.

    9. Numerical solutions of partial differential equations - numerical differentiation and the heat equation as an example parabolic equation

    Numerical differentiation, finite difference stencils and Pseudospectral methods. Solution of the heat equation as an example of method of lines.

    10. Numerical solutions of partial differential equations - classification, stability, well posedness, the wave equation as an example hyperbolic equation

    Revision of PDEs - types of PDEs and how this affects their solution. Well posednessMethods for solving hyperbolic (2nd order in time) equations as an IVP, the wave equation as an example.  CFL conditions and Von Neumann stability analysis.

    11. Numerical solutions of partial differential equations - implicit integration of PDEs, non linear PDEs and Poisson's equation as an example elliptic equation

    Use of implicit integration - the trapezoid method as an example. Non linear equations. Elliptic equations,  solving elliptic equations by relaxation, with a non linear Poisson equation as an example.

    12. Revision of key concepts for coursework (or other topics by request)

  • Assessment

    The assessment of the module “Topics in Scientific Computing” is based on two courseworks. The first coursework contributes 20% of the final mark, while the second coursework accounts for the remaining 80%. 

    The weekly quizzes are not compulsory, but are an excellent way of checking if you master the minimum learning outcomes for the course. However, the bulk of your learning will take place while you practice your coding skills in the lab and exercises.

    For the two courseworks you will need to upload a Jupyter Notebook which addresses an extended programming question and includes some short texts in the markdown format. The project will assess your coding and communication skills - in particular it will not only check that your solution works, but also that it is readable, clear and commented as appropriate.

    The first coursework will be uploaded at the start of Week 4 and will be due by the end of Week 9, while the second coursework will be uploaded at the start of Week 10 and will be due by the end of the January exam period (19 January 2024).

    When the courseworks are uploaded I will give more concrete information on the requirements, marking scheme, and restrictions on communication and collaboration with others, and use of ChatGPT resources. 

    Please note that previous year assessments for this course should not be considered as examples of the coursework this year - they will not be exactly the same format due to changes in the focus of the course and in particular changes to the coding language used. 

    If you do not pass the coursework on the first attempt, you will be reassessed based on another attempt at a coursework equivalent to the second only. Again further details will be provided if required - I hope that all students will be able to pass on the first attempt - should you have any concerns about your ability to do so please get in contact with me as early as possible.

  • Reading list and useful resources

    If you do not have a strong background in python, I suggest looking at the introductory module at QMUL here: https://test.qmplus.qmul.ac.uk/course/view.php?id=20561. This contains jupyter notebooks that discuss all the key python concepts at an appropriate level, and demonstrate their use. A useful and free reference that covers the topics of the first few weeks of the course in more detail (you can skip over Chapters 8-14) is:

    I do not particularly recommend using additional textbooks for the course material. It is better to focus on the course material itself and use online resources to support yourself, such as the manuals for python modules. One very useful resource that is close to the course is:

    For the differential equations, I recommend the YouTube video series of 3Blue1Brown for their intuitive explanation of the concepts:

    If you would like to explore the topics further, some recommended textbooks are:

    1. Numerical recipes: the art of scientific computing by W. H. Press, S. A. Teukolsky, W. T. Vetterling, B. P. Flannery (Cambridge University Press, 2007)

    2. Learning scientific programming with Python by Christian Hill (Cambridge University Press, 2015)

    Most of the suggested books are available from the QMUL Library, both in paper and electronic format, or freely available online, hence the students are neither required nor encouraged to buy any of those books.


  • Time commitment of module

    This module is heavily focused on practical applications of programming, and therefore students will need to spend time writing functioning computer programs in order to learn the techniques necessary for completion of the coursework. Coding (especially debugging and optimising code) can take a lot of time, and results are not always proportional to the time put in. However, be assured that it is time well spent - once you have made a trivial error and spent 2 hours looking for it, you will not make the same error again! I strongly believe that expertise in coding is proportional to the number of mistakes you have made (and learned from) in the past.

    For this reason the amount of time required to complete the module successfully may vary, but a suggested amount for a student with only a minimal background in programming would be 2-4 hours per week in addition to the lectures (2 hours per week) and lab (2 hours per week) and the coursework (see below). These 2-4 hours can be used to review the lecture notes (~30 mins), complete the weekly quiz (~30 mins), and finish any exercises not already completed in the labs (~1-3 hours). It is also important for students to look up details on any topics they are unfamiliar with, as they would do during a research or work project.

    For the coursework, we expect you to finish the second coursework within the equivalent of one working week, so about five whole days or 35hrs. This is in line with what you would need to revise for a written final exam. The first coursework is shorter and therefore we expect you to need around 2 working days to complete it.

  • Specific learning outcomes

    Specific learning outcomes week by week:


    Week 1:

    The aim of the session is to check that students can access an installation of python that includes the necessary modules for the course, download material from the course GitHub repository, and successfully run some simple code examples in the notebooks provided. 

    Specific intended learning outcomes:

    - Students can set up a virtual environment including numpy, scipy, math, mpi4py and sagemath. 

    - Students can clone the material from GitHub for the course into their home location

    - Students can explain why GitHub is used

    Week 2:

    The aim of the session is to  familiarise students with elements of computer programming in Python (and in general) and some "software carpentry" issues such as naming, debugging and storing code.

    - Students understand and can use types, variables, assignment, functions, loops, conditionals, and can name them appropriately according to standard coding conventions.

    - Students know how to load the Python libraries - NumPy, SciPy and Matplotlib - and access functions contained in them

    - Students understand the concept of version control

    - Students know how to comment code appropriately

    - Students know and can use defensive programming - writing tests before writing code

    Week 3:

    This week introduces classes and basic concepts for numerical solutions of ODEs.

    - Students can write simple classes, appropriately named, with functions to initialise attributes and methods to modify them and implement other desired behaviour in the class.

    - Students understand the advantages of using classes over functional programming styles

    - Students understand inheritance of classes and can implement it

    - Students understand private methods and attributes, and how to access non private functions and attributes

    - Students understand how to implement operators on classes, e.g. by defining  __add__ to add objects

    - Students can identify ODEs properties including: order, dimension, linearity, dependent and independent variable, autonomy, and explain their physical meaning for the solution

    - Students understand Euler's method for solving a first order ODE and can implement it in python

    - Students can use scipy's solve_ivp() function and compare the solutions

    - Students understand how step size affects error in Euler's solution and how this can be used to test convergence

    Week 4

    - Students understand why the simple Euler methods is problematic, in terms of convergence and stability

    - Students understand the concept of numerical instability and how it can be triggered

    - Students understand how methods that use intermediate estimates of the gradient improve stability

    - Students can implement the midpoint method in python and check its convergence order

    - Students are aware of the RK4 method and how it is used in solve_ivp()

    - Students understand how to recast a second order ODE into a higher dimension first order one

    - Students understand the difference between explicit and implicit schemes

    - Students can create phase plots and interpret them in terms of the energy of the system

    Week 5

    - Students can derive the conditions on step size for the forward Euler method to be stable in stiff systems

    - Students can implement the backwards Euler method for simple linear ODE systems

    - Students can prove that the backwards Euler method is unconditionally stable for any step size

    - Students can use sympy and numpy to take inverses of matrices, find their eigen decompositions, transpose them, find a determinant, multiply them. 

    - Students can use Sympy to solve simple linear ODE systems

    - Students understand the issues with taking inverses of large matrices

    - Students understand the difference between a numpy array and a numpy matrix and how this affects their use

    Week 6

    - Students can explain how to iterate at each timestep to solve non linear ODEs using implicit methods (in particular as part of the Backward Euler method)

    - Students know how to solve Ax=b using an iterative scheme

    - Students can calculate the row sum norm for a matrix

    - Students know what the spectral radius of a matrix is, and the condition on this for convergence of an iterative scheme

    - Students can calculate the condition number of a matrix and know the condition on it for the associated matrix problem to be well conditioned

    - Students can describe the issues will ill conditioned problems

    - Students know the conditions for an initial value problem to be well posed, in terms of existence, uniqueness and continuous dependence on initial data

    - Students are aware of the Lipshitz continuous test for well posedness for ODEs

    Week 7 (optional)

    - Students can explain the difference between message passing and shared memory parallelisation paradigms

    - Students know how to use basic MPI4py functions to send and receive values between processes

    - Students know terminology: process, processor, core, node, thread, rank, OpenMP, MPI, clock speed

    - Students can identify problems that can and cannot be parallelised

    Week 8

    - Students can construct a Lagrange polynomial through a set of points

    - Students understand why Taylor polynomials are not a good basis

    - Students understand and can identify Runge's phenomenon

    - Students can find the Gauss Lobato nodes in an interval and construct the colocation polynomial

    - Students can use numerical quadrature to find integrals, using Simpsons rule, Trapezoidal rule, Hermite rule and their composite versions

    - Students are aware of Gaussian quadrature and why it is more efficient, and can use if for a small number of points.

    Week 9

    - Students can construct finite difference stencils from a set of points by constructing the Lagrange polynomial through them

    - Students can calculate the order of derivative approximation for a given number of points

    - Students know the relation between the finite difference stencils and matrix representations, and can use them to calculate derivatives

    - Students can use (but need not derive) the derivative matrices for pseudospectral differentiation, by rescaling the integral and constructing the relevant points.

    - Students know the heat equation and can solve it using the method of lines. They understand physically why it results in a smoothing of the initial data.

    Week 10

    - Students can identify hyperbolic, parabolic and elliptic equations by their coefficients for one dimensional cases with two independent variables. 

    - Students can discuss the properties of each type of equation, their solutions, and name one example of each.

    - Students can explain what a Cauchy problem/initial value problem is.

    - Students understand the concept of well posedness, and can explain existence, uniqueness and continuous dependence on the initial data.

    - Students know that linear hyperbolic and parabolic equations are well posed, but elliptic equations are not, and what this means for their solution as an initial value problem.

    - Students know the approximate CFL conditions for hyperbolic and parabolic equations and can find the limits by trial and error in simulations.

    - Students know the process by which a CFL condition is derived. 

    - Students know the signs of ill posed problems and the difference to instabilities from the CFL condition.

    Week 11

    - Students can use implicit integration schemes with PDEs, with the trapezium rule as an example.

    - Students understand how non linear terms change the solution of PDEs. 

    - Students know the more general conditions for hyperbolicity for higher dimensional system, in terms of the eigenvalues and vectors of the characteristic matrix.

    - Students know how to solve elliptic equations as a boundary value problem using relaxation (by casting it as a parabolic equation), with the Poisson equation as an example.

  • Q-Review

  • Early feedback questionnaire

  • Feedback to students

    There are several different ways in which feedback will be provided to students during the module:

    • All students are encouraged to post questions on the QM+ forum in the module webpage. This way, all students can see and benefit from frequently asked questions. Students are also encouraged to answer their fellow students’ questions on the forum if they feel comfortable doing so.
    • The weekly quiz allows students to check that they have mastered the basics of the learning outcomes for each week.
    • Availability to ask questions during or after lectures
    • Participation in IT Labs throughout the week - these provide you with a unique opportunity to work with other students and explore ideas from the module in further depth. Labs are also a more relaxed environment for you to get advice and guidance for your course from the lecturer, who will provide helpful comments. 
    • Personalised feedback during office hours - Office hours are also an opportunity for you to get 1 on 1 help for any additional support you may need. You can also contact the lecturer by email with any queries you might have, but visiting during office hours is preferred.
    • The students will be given detailed feedback on the initial coursework, to help them identify the strengths and weaknesses of their submissions and improve for the second major submission.
    Feedback is not just written comments on a piece of work. Please make sure that you actively engage with all these feedback opportunities, as they are there to help you learn and gain confidence in tackling unfamiliar problems!

  • FAQ on coursework

    (With thanks to the authors of course MTH5001, Thomas Prellberg and Matthew Lewis for this useful FAQ list)

    0. For coursework 1, I don't know how to formulate the ODEs for stars, and what units to use, I'm a mathematician not an astronomer!     Since I don't want to test this aspect of your learning, I have provided a file below that gives the equations explicitly. It should be self explanatory, but should you have any questions about the notation please ask.

    1. How do I get started? Please read the instructions and attempt to understand the mathematical background behind the project before writing any code. It will be very difficult to write code if you don't know what the code is supposed to be doing.

    2. How do I convert project.ipynb to pdf? First of all, why would you want to do this? You will need to fill this in on a computer anyway. Secondly, it might be easier to share the pdf, which is something you are not allowed to do, especially once you have added your own work to it. Finally, Jupyter Notebook opens in a browser window (yes, even on appsanywhere) and you can simply "print" to pdf. 

    3. How should I include references in my report? Do I need a bibliography? Do I need to reference code that I find on the internet? If you need to cite references then you can include a bibliography if you like, or simply cite your references when you use them (in the markdown documentation sections of your code). I don't really mind, as long as you make it absolutely clear what sources you have used. If you use code (including functions) that you didn't write yourself, you must cite your sources, including ChatGPT (in which case it might be appropriate to comment on any errors you noted in the solution it provided, or how you had to change it for the naming conventions, etc). You must, however, work independently from other students on the course, and submit your own independent attempt at the coursework. Submissions will be checked for similarity of solutions. 

    If you happen to find a question on the internet that looks like it has been posted by anyone working on this coursework, it would be really dangerous to use any material related to that. Whoever posted that is liable to face an assessment offence charge, and if you used that material, you’d become complicit. 

    4. Can you read my report and give me feedback before I submit it? No, sorry. This would be like giving feedback on a written exam before you hand it in. (Of course, you are free to ask me specific questions.) 

    5. Can you tell us more about the use of Turnitin? Is there a threshold percentage? Please refer to http://www.library.qmul.ac.uk/plagiarism for guidance on the plagiarism requirements for the university. I cannot say more.

    6. How do you approach marking the Project? When I open the Notebook, I first run it from scratch ("restart the kernel, then re-run the whole notebook"). Any output will therefore be overwritten by what is generated from scratch, and I EXPECT TO SEE NO ERRORS when I run the notebook. Don't submit buggy code, or, if you absolutely must, comment it out with # and explain why you didn't just delete it.

    7. How long do you expect the work on the coursework to take? We expect you to finish the second coursework within the equivalent of one working week, so about five whole days or 35hrs. This is in line with what you would need to revise for a written final exam. The first coursework is shorter and therefore we expect you to need around 2 working days to complete it.

    8. My code takes X seconds to run, will I lose marks if it is inefficient? We first and foremost mark for correctness, not speed. Most solutions should take a few seconds to run, so if your code takes more than a few minutes it is grossly inefficient and maybe you should worry, otherwise you’re likely fine.