IN PYTHON:

Write a class Matrix. Objects in this class maintain an m×n matrix. (We'll handle pairs of numbers as tuples). Store the matrix in a list or list of lists, whichever you prefer.

Keep track of the shape m × n. Include the following basic methods.

Matrix((m,n)) Provide a constructor that sets the shape of the matrix and sets all the entries to a default value of zero.

newMatrix The call newMatrix((m,n)) clears the existing data in the Matrix and sets it to a matrix of zeros of shape (m,n)

getShape getShape() returns a tuple giving the shape of the matrix. getElement The call getElement((i,j)) returns the element at row i

and column j.
setElement The call setElement((i,j), value) sets the entry at position (i, j) to value.

The rest of the methods should use those above in order to be independent

of the internal implementation of the matrix.

setElements Takes a dictionary D where the keys are tuples (i,j) and the values are numbers. For each key, it sets the element at position (i,j) to D[i,j].

SetByRows Takes a list of lists. The inner lists give values for each row, so the outer list describes the matrix. For example [[1,2], [3,4]] sets the matrix to the matrix with first row 1 2 and second row 3 4 . This method will clear the existing data and reset the shape.

For the matrix operations, we want the user to provide the target object. So, if we have A and B, the user should provide an existing matrix object C to store the result.

Thus C.add(A,B) should reset the data in C (using methods above) to the matrix sum of A and B. For simplicity, C should not be A or B. Provide methods for scalar multiplication and matrix multiplication. For example C.scalarMult(num, A) should set C to the result of multiplying A by the scalar num. For matrix multiplication, C.mult(A,B) should set C to the matrix product of A and B.

Also provide a method duplicate so that C.duplicate(A) sets C to the same mathematical matrix as A.

B. In many applications, you have huge matrices, but most of the elements of the matrix are zeros. It's inefficient to store all those zeros, it's only necessary to store the nonzero elements. Here is one approach to this idea.

Define a subclass of Matrix called SparseMatrix. In a sparse matrix, we keep track of the nonzero elements in a dictionary. The keys are tuples (i,j) giving the location of the element and the value assigned to this key gives the value of the nonzero element.

If a tuple (i,j) does not appear in the dictionary, the matrix element at that location is assumed to be zero. When creating or modifying a sparse matrix, we don't want to store zero entries.

In the class SparseMatrix override some (but as few as possible) of the parent class Matrix to make sparse matrices work anywhere you can put a Matrix.