Summary of MyProgram, a demo of
                     -------------------------------
                       the matrix class MyMatrix
                       -------------------------

S. L. Keeling, October 2004
keeling@uni-graz.at
+43-316-380-5156

Abstract
--------
    MyProgram is a simple program which reads an array of matrices from
a read-only data file into global variables, performs some operations on
these matrices, stores the results of the operations in an array of
global matrices, and prints the computed results into a write-only data
file.  The concept of a class is demonstrated with the matrix class
MyMatrix.  This class has basic matrix operations overloaded in the
definition of the class.  There are also class friend functions used
to show a matrix and its dimensions.  There is no fixed limit on the
size of matrices which can be processed, and the elements are stored
in dynamic memory.  For the simple examples shown, the matrix
dimensions are read from a data file.  The matrices defined are
established as global variables and the extern command is used in
called functions.  The concept of Input/Output isolation is demonstrated
by calls to specialized functions for file manipulation.

MyProgram from a User's Perspective.
-----------------------------------
    There is a single input file for MyProgram, MatrixIn.dat, which
contains the input matrices, A[n], n=0,(nA-1).  There is also a
single output file for MyProgram, MatrixOut.dat, which contains the
output matrices, B[n], n=0,(nB-1).  The operations performed on the
input matrices and stored in the output matrices can be altered in
body.  The format of the input and the output can be altered in
ReadFile and in WriteFile.

Input File:  MatrixIn.dat
-------------------------
    There is a single input file for MyProgram, MatrixIn.dat, which is a
text file with the following format which can be seen in ReadFile.cpp:

          nA
          A[0].nrows
          A[0].ncols
          A[0].matrix(1,1)
          A[0].matrix(1,2)
          ...
          A[0].matrix(1,A[0].ncols)
          ...
          A[0].matrix(A[0].nrows,1)
          A[0].matrix(A[0].nrows,2)
          ...
          A[0].matrix(A[0].nrows,A[0].ncols)
          :::
          A[nA].nrows
          A[nA].ncols
          A[nA].matrix(1,1)
          A[nA].matrix(1,2)
          ...
          A[nA].matrix(1,A[nA].ncols)
          ...
          A[nA].matrix(A[nA].nrows,1)
          A[nA].matrix(A[nA].nrows,2)
          ...
          A[nA].matrix(A[nA].nrows,A[nA].ncols)

where A is a pointer to the matrix class, and its elements are
established dynamically.  Note that nA and A are global variables.

Output File:  MatrixOut.dat
---------------------------
    There is a single output file for MyProgram, MatrixOut.dat, which
is a text file with the following format, which can be seen in
WriteFile.cpp:

          nB
          B[0].nrows
          B[0].ncols
          B[0].matrix(1,1)
          B[0].matrix(1,2)
          ...
          B[0].matrix(1,B[0].ncols)
          ...
          B[0].matrix(B[0].nrows,1)
          B[0].matrix(B[0].nrows,2)
          ...
          B[0].matrix(B[0].nrows,B[0].ncols)
          :::
          B[nB].nrows
          B[nB].ncols
          B[nB].matrix(1,1)
          B[nB].matrix(1,2)
          ...
          B[nB].matrix(1,B[nA].ncols)
          ...
          B[nB].matrix(B[nB].nrows,1)
          B[nB].matrix(B[nB].nrows,2)
          ...
          B[nB].matrix(B[nB].nrows,B[nB].ncols)

where B is a pointer to the matrix class, and its elements are
established dynamically.  Note that nB and B are global variables.


Standard Output:
----------------
    The matrices read, the types of matrix calculations performed,
and the results of the calculations are reported on the screen:

          0th read matrix:
          elements...
          :::
          nAth read matrix:
          elements...
          Matrix operations performed:
          B[0] addition
          B[1] subtraction
          etc.
          :::
          B[0]
          elements...
          :::
          B[nB]
          elements...


Compilation
-----------
    The makefile partitions those functions depending upon the class
include-file into SRC1 and those functions depending additionally upon
the non-class include-file into SRC2.  The object files are analogously
partitioned into OBJ1 and OBJ2.  The executable file depends upon the
OBJ1 and OBJ2 files.  The executable is built by typing "make all".
The directory can be cleaned by typing "make clean".