Matrix inverse and transpose ...

Hello experts,

    I am working on a matrix class for practice. I just added a inverse and transpose function, and have some questions about the class ? I would appreciate someone to give me some suggestions.

1. In the inverse function, I have problem to do :
    for(int i =0; ...) ... for the second time... so that I have to declare things like: int ii =0 , or iii =0 ...
    does anyone know why ? since sometimes I don't have this problem...

2. For the + and - operator member function, I decide to return by value ... because in C= a+b
   I do not want to change anything of a ! is this the best way to implement "+" and "-" ??? thanks.

3. in the inverse function, sometimes I have values like : 1.2e-15
    so ... when we print it out, it looks bad ... what would be a better way to print out things ?

4. any suggestions to improve the matrix class ? many thanks.

-----------------------------------------
// Matrix class ...

#ifndef _MatrixH_
#define _MatrixH_

#include <iostream>
#include <sstream>
#include <iomanip>


using namespace std;

//template <class T>

typedef double T;

class Matrix
{
      public:
            Matrix(size_t row =1 , size_t column=1):M(row),N(column), data(new T[M*N]){}

            Matrix(const Matrix& B):M(B.M),N(B.N), data(new T[M*N])
            {
            for(int i=0; i<M*N; i++)
                  {
                        data[i]= B.data[i];
                  }
            }

            Matrix& operator=(const Matrix& B)
            {      
                  for(int i=0; i<M*N; i++)
                  {
                        data[i]= B.data[i];
                  }

                  return *this;
            }

            Matrix operator+(const Matrix& B)
            {
                int B_M = B.getRow();
                int B_N = B.getColumn();
                  if(B_M != M || B_N!= N)
                  {
                        throw "Dimension do NOT match !" ;
            }
                  
                  Matrix C(M,N);
            for(int i=0; i<M*N; i++)
                  {
                        C.data[i] = data[i] + B.data[i];
                  }

                  return C;
            
            }
       

            
            Matrix operator-(const Matrix& B)
            {
                int B_M = B.getRow();
                int B_N = B.getColumn();
                  if(B_M != M || B_N!= N)
                  {
                        throw "Dimension do NOT match !" ;
            }
                  Matrix C(M,N);
            for(int i=0; i<M*N; i++)
                  {
                        C.data[i] = data[i]-B.data[i];
                  }

                  return C;
            
            }


            Matrix operator*(const Matrix& B)
            {
                int B_M = B.getRow();
                  int B_N = B.getColumn();
                  if( N!= B_M)
                  {
                        throw "Dimension for multiplication do NOT match !" ;
            }
                  
                  Matrix C(M,N);
         /*-------------------------------------------------------------
             //  Standard implemetion of matrix multiplication formula

                 for(int i=0; i<M; i++)
                        for(int j=0;j<B_N; j++)
                        {      
                              C.data[i*N+j]= 0;
                              for(int k=0; k<N;k++)
                              C.data[i*N+j]+= data[i*N+k]* B.data[k*N+j];
                        }
             //----------------------------------------------------------- */
         
             //-------------------------------------------------------------
             // An optimized way to speed up the multiplication calculation
             
                  for(int i=0, e=0; i<M; i++)
                for(int j=0;j<B_N; j++, e++)
                {    
                    T val = data[i*N] * B.data[j];
                    for(int k=1, c = i * N+1, d = j + B_N; k<N;k++, c++, d += B_N)
                       val += data[c]* B.data[d];
                   
                              C.data[e] = val;
                        }                  
          //---------------------------------------------------
              return C;
            }

            //----------------------------------------------------
            // A way to read & write matrix element, using (i,j)
            T operator()(size_t i, size_t j) const { return data[i * N + j]; }
            T& operator()(size_t i, size_t j) { return data[i * N + j]; }
        //-----------------------------------------------------

            //----------------------------------------------------
            // Another way to read & write matrix elemnt, using[i][j]

             T* operator[](size_t i) {return (data + (N*i));}
         T const*const operator[](size_t i) const{return (data + (N*i));}
     
             //----------------------------------------------------
             Matrix transpose()
             {
                   Matrix trans(N,M);
                   for(int j=0; j<N; j++)
                         for (int i=0; i<M; i++)
                         {
                               trans.data[j*M+i] = data[i*N+j];
                         }
                   return trans;
             }

             Matrix inverse()
             {
                 if(M!=N) throw "Only Square Matrix can have inverse!";
                   Matrix SI(M,2*M);

                   for(int i=0; i<M;i++)
                   {
                         for(int j=0; j<2*M; j++)
                         {
                               if(j<M)
                               {
                                    SI.data[i*2*M+j] = data[i*M+j];
                               }
                               else
                               {
                                    SI.data[i*2*M+j] = 0;
                               }

                             if(j==i+M) SI.data[i*2*M+j] =1.0;
                         }
                   }


                   for(int ii=0; ii<M-1; ii++)
                   {
                        for(int kk=ii+1; kk < M; kk++)
                        {
                              for(int jj=2*M-1; jj>=ii; jj--)
                              {
                                    SI.data[kk*2*M+jj] -= SI.data[ii*2*M+jj] *
                                                  (SI.data[kk*2*M+ii]/SI.data[ii*2*M+ii]);
                              }
                        }
                   }      
         
                   //-------------------------------------

                 for(int iii=M-1; iii>0; iii--)
                   {
                        for(int kkk=iii-1; kkk >=0; kkk--)
                        {
                              for(int jjj=2*M-1; jjj>=iii; jjj--)
                              {
                                    SI.data[kkk*2*M+jjj] -= SI.data[iii*2*M+jjj] *
                                                  (SI.data[kkk*2*M+iii]/SI.data[iii*2*M+iii]);
                              }
                        }
                   }      

                   for(int iiii=0; iiii<M; iiii++)
                   {
                        for(int jjjj=2*M-1; jjjj >=0; jjjj--)
                        {
                              SI.data[iiii*2*M+jjjj] =SI.data[iiii*2*M+jjjj]/SI.data[iiii*2*M+iiii];                     
                        }
                   }      

                   Matrix I(M,M);
                   for(int s = 0; s<M; s++)
                         for(int r=0; r<M; r++)
                         {
                               I.data[s*M+r] = SI.data[s*2*M+r+M];
                         }
                   return I;
                   //---------------------------------
             }

            //---------------------------------
            // A standard print() function, printing things to standard IO
            void print(ostream& ss)
            {
                  for (int i = 0, c = 0; i < M; i++) {
                        for (int j = 0; j < N; j++,c++) {

                              ss << setw(20) << data[c] ;
                        }
                        ss << endl;
                  }
            }
            //---------------------------------------------

            //-----------------------------------
            // A general print() function for possible future non-standard IO
            template<class Streamlike>
            void printStream(Streamlike s)
            {
                  for (int i = 0, c = 0; i < M; i++) {
                        for (int j = 0; j < N; j++,c++) {
                              s << setw(4) << data[c] ;
                        }
                        s << endl;
                  }
            }
            //------------------------------------

           ~Matrix()
            {      
                        delete [] data;
            }
            
      protected:
            int getRow() const {return M;}
            int getColumn() const {return N;}

      private:
            int N, M;
            T *data ;
};

#endif