Topic: Inheritance Design
Due: 5:00pm Wednesday, 3 November 2010

Please make sure you adhere to the policies on academic integrity.

Introduction

In class, we outlined a new high-level design for our matrix suite. It makes use of inheritance to avoid the unnecessary repetition of implementation details. Specifically, we rely on the definition of an abstract base class named matrix_expression, which serves as the parent of two concrete classes named matrix and matrix_proxy.

In this assignment, we explore the details of the design and test your intuitions for what behaviors can be easily reused and what behaviors are specific to one class. For example, in the previous assignment we explored various forms of addition. What you hopefully noticed is that doing addition of proxies with each other, or one proxy and one matrix, is really the same logic as when adding two matrices; in all cases we needed to create a new matrix instance, and then to set the elements to be the sum of the respective elements from the two operands. In our new design, we will place this implementation at the level of matrix_expression, so that it can be shared by all. Its formal signature will be described as

   matrix matrix_expression::operator+(const matrix_expression& other) const;

   returnType class::function(params);

Your Task

We want to test your intuitions as you consider many subtle cases that may arise in our new framework. For each of the following sample syntaxes, consider where and how you think such a behavior is most naturally defined. In particular, we want you to give a complete signature using the form shown above. Make clear in which class the behavior belongs, the type and form of the parameter passing and the return value. Make sure to rely on your understanding of the inner-workings of the matrix and matrix_proxy classes.

For each of the following, you are to given the full signature, and you must provide a written explanation for why you have chosen such an answer. We will get you started with our answer to #0.

0. A + B
   

      matrix matrix_expression::operator+(const matrix_expression& other) const;
   

   The syntax A+B is supported by the operator+ function in C++.

   We place this behavior in the matrix_expression class, and with a matrix_expression parameter, because we are able to add any two objects that qualify as matrix expressions (e.g., matrix + matrix, matrix + proxy, proxy + matrix, proxy + proxy), so long as the dimensions agree. This is possible because we simply need to compute element-by-element sums and all matrix expressions support basic (r,c) indexing to access individual elements.

   The two occurrences of const are there because the evaluation of expression A+B should have no lasting effect on either of the individual operands. Rather, it should generate a new resulting sum.

   We have chosen matrix as the return type because we need to create new storage for the result, as the element sums are not explicitly stored in either of the individual operands.

1. A + 5
2. A * B
3. A * 5
4. A(range(2,4), range(3,8))
5. A.size()
6. A.reshape(4,3)
7. A += B
8. A *= 5
9. A == B
10. A = B
    (think carefully about how this may depend on the underlying type of A and B)

Submitting your assignment