这是一个英国的Java编程作业代写案例

## 1 Formulation of the Problem

Matrices are one of the most important mathematical concepts to be modelled by computer, being used in

many problems from solving simple linear systems to modelling complex partial differential equations.

Whilst a matrix (in our formulation) is simply an element of the vector space ℝ!×#, it usually possesses some

structure which we can exploit to gain computational speed. For example, a matrix-matrix multiplication

generally requires of the order of 𝑛$ floating-point operations. If the matrix has some special structure which

we can exploit using a clever method, then we might be able to reduce this to 𝑛 operations. For large values

of 𝑛, this significantly improves the performance of our code.

In this project, you will write two classes representing matrices of the form:

𝐴 is a dense 𝑚 × 𝑛 matrix which, in general, has no special structure and no zero entries. 𝐵 is a tri-diagonal

matrix, where all entries are zero apart from along the diagonal and upper and lower diagonals. Note that

although 𝐵 is only a 5 × 5 matrix, your classes should represent a general 𝑛 × 𝑛 tri-diagonal matrix. Also,

the tri-diagonal matrices you need to represent will always be square.

In a similar fashion to Fraction, you will then write functions to perform various matrix operations:

1. addition and subtraction;

2. scalar and matrix-matrix multiplication;

3. calculating the determinant of the matrix.

Clearly calculating the determinant is the trickiest task here. Probably you will already have seen expansion

by minors as a possible method. Whilst this is an excellent method for calculating determinants by hand, you

should not use it for this task. The reason is that calculating the determinant of a 𝑛 × 𝑛 matrix requires 𝑂(𝑛!)

operations, since for each 𝑛 × 𝑛 matrix, we must calculate the values of the 𝑛 − 1 sub-determinants. This

is extremely slow.

A much better method is called LU decomposition. In this, we write a matrix 𝐴 as product of two matrices 𝐿

and 𝑈 which are lower- and upper- triangular respectively. For example, for a 4×4 matrix, we would find

matrices so that

Such a factorisation is not guaranteed to exist (and indeed is not unique), but typically it does. In this project,

you don’t really need to worry about this – your code will be tested with matrices for which the LU

decomposition exists. It is up to you to figure out how to calculate the determinant from the LU

decomposition!

Throughout the formulation, matrices will be represented by indices running between 1 ≤ 𝑖, 𝑗 ≤ 𝑚, 𝑛.

However, in your code, you should stay consistent with Java notation and indices should start at 0

(i.e. 0 ≤ 𝑖, 𝑗 ≤ 𝑚 − 1, 𝑛 − 1).

## 2 Programming Instructions

On the course web page for the project, you will find files for the following classes. As with the previous

projects, the files have some predefined methods that are either complete or come with predefined names

and parameters. You must keep all names, parameter types and return types of public objects and

methods as they are in the templates. Other methods must be filled in and it is up to you to design them

properly.

There are five classes in this project:

• Matrix: a general class defining the basic properties and operations on matrices.

• MatrixException: a subclass of the RuntimeException class which you should use to throw

matrix-related exceptions. This class is complete – you do not need to alter it.

• GeneralMatrix: a subclass of Matrix which describes a general 𝑚 × 𝑛 real matrix.

• TriMatrix: another subclass of Matrix which describes a 𝑛 × 𝑛 real tri-diagonal matrix.

• Project3: a separate class which will use Matrix and its subclasses to collect some basic statistics

involving random matrices.

• Please note that unlike other projects, you may not assume that the data you receive will be valid.

Therefore, you will need to check, amongst other things, that matrix multiplications are done using

matrices of valid sizes, the user is not trying to access matrix elements which are out of bounds, etc. If

something goes wrong, you are expected to throw a MatrixException.

The classes you need to work on are briefly described below.

### 2.1 The Matrix class

This is the base class from which you will build your specialised subclasses. Matrix is abstract – as described

in the lectures, this means that some of the methods are not defined, and they need to be implemented in

the subclasses. The general idea is that each subclass of Matrix can implement its own storage schemes,

whilst still maintaining various common methods inherent in all matrices.

In particular, the following functions are not abstract, and need to be filled in inside Matrix:

• the protected constructor function;

• toString, which should return a String representation of the matrix.

Additionally, the following abstract methods will be implemented by the subclasses of Matrix:

• getIJ and setIJ: accessor and mutator methods to get/set the 𝑖𝑗th entry of the matrix.

• add: returns a new Matrix containing the sum of the current matrix with another.

• multiply(double scaler): multiply the matrix by a constant 𝑠𝑐𝑎𝑙𝑎𝑟 ∈ ℝ.

• multiply(Matrix B): multiply the matrix by another matrix. Note that this is intended to be a

left multiplication; i.e. A.multiply(B) corresponds to the multiplication 𝐴𝐵.

• random(): fills current the matrix with random numbers, uniformly distributed between 0 and

1. For a tri-diagonal matrix, this should fill the three diagonals with random numbers.

In subclasses, you should pay attention to what type of matrix needs to be returned from each of the

functions. For example, when adding two GeneralMatrix objects the result should be a

GeneralMatrix (which is then typecast to a Matrix).

**程序代写代做C/C++/JAVA/安卓/PYTHON/留学生/PHP/APP开发/MATLAB**

本网站支持淘宝 支付宝 微信支付 paypal等等交易。如果不放心可以用淘宝交易！

**E-mail:** itcsdx@outlook.com **微信:**itcsdx

如果您使用手机请先保存二维码，微信识别。如果用电脑，直接掏出手机果断扫描。