    The reader might wonder what happens if we define the following matrix:
        verb(
    Matrix<1, 1> cell;
        )
    Is this a tt(MatrixRow) or a tt(MatrixColumn) specialization? The answer
is: neither.

It's ambiguous, precisely because em(both) the columns em(and) the rows could
be used with a (different) template partial specialization. If such a
tt(Matrix) is actually required, yet another specialized template must be
designed.

Since this template specialization can be useful to obtain the sum of the
elements of a tt(Matrix), it's covered here as well.
    itemization(
    it() This class template partial specialization also needs a template
header, this time only specifying tt(DataType). The class definition specifies
two fixed values: 1 for the number of rows and 1 for the number of columns:
        verbinclude(//MATRIX1X1 examples/matrix.h)
    it() The specialization defines the usual batch of constructors.
Constructors expecting a more generic tt(Matrix) type are again implemented as
member templates. For example:
        verbinclude(//1X1CONS examples/matrix.h)
    it() Since tt(Matrix<1, 1>) is basically a wrapper around a tt(DataType)
value, we need members to access that latter value. A type conversion
operator might be useful, but we also defined a tt(get) member to obtain
the value if the conversion operator isn't used by the compiler (which
happens when the compiler is given a choice, see section
ref(ConversionOperators)). Here are the accessors (leaving out their tt(const)
variants):
        verbinclude(//ACCESSORS examples/matrix.h)
    )

    Finally, the tt(main) function shown below illustrates how the tt(Matrix)
class template and its partial specializations can be used:
    verbinclude(-a examples/matrix.cc)
