The next abstract class of interest is `ClpMatrixBase`.
CLP encapsulates its knowledge of how a matrix is stored in this class. The
default instance of this is the `ClpPackedMatrix` class.
This is identical in format to `CoinPackedMatrix`. Below
is a diagram summarizing the hierarchy of the most important matrix classes:

The important new methods implemented are for filling a basis, checking validity
of elements and faster "times" and "transposeTimes" when
the input array is sparse and/or we have a row copy of the matrix. Advanced
users should note that not all methods have to be implemented. In particular,
`scaling` need not be implemented and
`reverseOrderedCopy` can return * NULL*
if a row copy does not make sense.

In addition to the default class, there are two others at present:
`ClpPlusMinusOneMatrix` and
`ClpNetworkMatrix`. As the name implies, the first one is
useful when all elements are ±1. In this case multiplies are not needed
and more importantly less memory is used and there are fewer cache misses. A
class for a matrix where all elements are +1 would be trivial to create. If
there were fewer than 64000 rows one could even store row indices as shorts
etc.

The use of `ClpPlusMinusOneMatrix` involves some work as one
cannot simply read-in an MPS file. The key is to use
`loadProblem` to pass in a matrix. So if
`matrix` was a `CoinPackedMatrix` one
could do the following:

ClpPlusMinusOneMatrix plusMinus(matrix); assert (plusMinus.getIndices()); // would be zero if not +- one model.loadProblem(plusMinus, lowerColumn,upperColumn,objective, lower,upper);

`ClpNetworkMatrix` is similar, but represents a network,
thus may only have one element per column. Fortunately, using is is very
easy. Given `head` and `tail`, one could
do the following:

ClpNetworkMatrix network(numberColumns,head,tail); model.loadProblem(network, lowerColumn,upperColumn,objective, lower,upper);

Actual code is in `COIN/Clp/Test/unitTest.cpp`. A quick
glance at the output of this program shows that use of
`ClpNetworkMatrix` gives much faster run times. This is
not because of storage issues, but because CLP recognizes the network and uses
a network basis factorization which is much faster. However, in this mode CLP
is not a genuine network code as it does not take full advantage of the
structure by combining operations but it does have the advantage of
flexibility.

Other instances are possible. In particular, it should be possible to use the abstract class for column generation or for dynamic matrices which change over time. Minor modifications may be needed but it should work quite smoothly (there is already a dummy "refresh" method which would be used).