讲解MATH 6141、辅导Python设计、讲解algorithms、讲解Python编程

Coursework 2: MATH 3018/MATH 6141 - Numerical

methods

Due: 13 December 2018

In this coursework you will implement given numerical algorithms. The assessment

will be based on

sensible choice and explanation of the algorithms – 4 marks

correct implementation of chosen algorithms – 5 marks

documentation, testing and error checking of code – 3 marks

appropriate convergence tests – 3 marks.

The deadline is noon, Wednesday 13 December 2018 (week 11). For late submissions

there is a penalty of 10% of the total marks for the assignment per day after the

assignment is due, for up to 5 days. No marks will be obtained for submissions that are

later than 5 days.

Your work must be submitted electronically via Blackboard. Only the Python files

needed to produce the output specified in the tasks below is required.

1

1 Political pricing

The government has told a monopoly company that it must reduce prices by 10% over

the next year or receive crippling fines. The company wants to do this as slowly as

possible to maximize profits, but realizes that its customers will put off buying its

goods, despite the monopoly, if they think they can get a better deal by waiting. The

company assumes that it therefore wants to set its prices (in dimensionless units) so

that y(0) = 1, y(1) = 0.9 (a 10% decrease over one year), and so that their profit

(which is modelled as the charge y minus a penalty due to customers waiting for the

future) is as large as possible.

Assuming the penalty is

P(t; ˙y) = α ( ˙y)

2 + β(t

2 1) ( ˙y)

3

,

your task is to find the solution y(t) that maximizes the profit by minimizing

S =

Z 1

0

(P y) dt (1)

subject to the boundary conditions y(0) = 1, y(1) = 0.9.

This is in the form of a variational problem where the task in to minimize the action

S =

Z b

a

L(t, y(t), y˙(t), y¨(t), . . .) dt, (2)

where L is some function of t and y and its derivatives, subject to boundary conditions

on y(t). This can be done using the Euler-Lagrange equations,

y(a) = A, y(b) = B. (3)

By using the chain rule we can expand this to give

, y(a) = A, y(b) = B. (4)

2

2 Task

1. Write an algorithm to solve the boundary value problem given by the EulerLagrange

equation (4). If your algorithm is not completely general you should

state the restrictions required in order for the algorithm to work. Your algorithm

should take as input the function L and the boundary values y(a), y(b) but must

compute all derivatives in equation (4) numerically. Justify your choice of algorithm.

2. Maximize the profit for the company for the two models

(a) α = 5 = β;

(b) α =

7

4

, β = 5.

For the second case, give evidence that your solution is converging in an appropriate

sense. Also state if the mathematical problem has been posed correctly to

solve the original problem.

2.1 Summary and assessment criteria

You should submit the code electronically as noted above.

2.1.1 Python

As Python allows for many function definitions in one file, you may submit as many

Python files as necessary to solve the problem. However, one file should clearly be the

master script that when run (eg from the console inside spyder), produces all the plots

required.

2.1.2 Plots

The code you submit will, if it answers all the tasks, produce at least 3 (three) figures:

1. For the first (α = β) case, the price curve y(t) as a function of t;

2. For the second (α 6= β) case, the price curve y(t) as a function of t;

3. For the second case (α 6= β), at least one figure showing evidence that your

algorithm is converging to some solution as you vary its accuracy.

Plots should be displayed to the screen.

2.1.3 Assessment criteria

The primary assessment criteria will be the

choice and justification of the algorithm: this must be explained and documented

in comments within the code, preferrably at the start of the main file;

3

correct implementation and use of your chosen algorithm: this will be shown

through the tests above and the figures produced.

The secondary assessment criteria will be the clarity and robustness of your code.

Your functions and scripts must be well documented with appropriate internal comments

describing inputs, outputs, what the function does and how it does it. The code

should also be well structured to make it easy to follow. Input must be checked and

sensible error messages given when problems are encountered. Unit tests of individual

functions may also be used to show the correctness of the code. The clarity of the

output (such as plots or results printed to the command window) is also important.

Code efficiency is not important unless the algorithm takes an exceptional amount

of time to run. As an indication, the model implementation runs all tasks in a maximum

of 2 minutes.