flyopunta/src/src_uti/gmatrix.h

/***************************************************************************
                          gmatrix.h  -  description
                             -------------------
    begin                : Febbraio 2006
    copyright            : (C) 2000 by Giuseppe M Pierazzini
    email                : pierazzini@unipi.it
 ***************************************************************************/
#ifndef GMATR_H
#define GMATR_H

#include <cmath>
void REPORT_ERROR(int, const char * tit);

//#include "gvet.h"
class gvet;
class gmatrix
 { 
protected:
    int Col,Row,Elem;
    double **ValM;
   
public:

   double detrm;  // determinante
   int okflag;
   
   // constructor 
   gmatrix();               // Matrice vuota di dimesioni nulle 
   gmatrix(int ,int);       // Matrice vuota di dimesioni intXint 
   gmatrix(int ,double);    // Matrice diagonale di dimesioni intXint e diagonale con double  
   gmatrix(const gmatrix & m);   // make a new matrix like m
   gmatrix(const gvet & gv);     // crea una matrice(3,1) da un vettore tridimensionale gvet  
  ~gmatrix();
  
   void Set_Size(int,int);   //resizes the matrix
   gmatrix  Proj(const gvet & );    //definisce in this il  tensore (proiettore  |v><v| ) dal vettore gvet v;  
   gvet & Get_Vcol(gvet &);  // restituisce un vettore definito come la colonna 0 della matrice "this".
   void Reset();             // matrix clearing 
   void Null ();             // annulla la matrice 
   void Unit ();             // 1. on the diagonal, 0, off diagonal.
   
   
 // Assignment operators

  gmatrix operator = (const gmatrix& ); // copy of the matrix into new matrix
  gmatrix operator = (const gvet & ); // fills a (3,1) matrix with a gvet values
  
   gmatrix  operator ~ ();  //transpose
   gmatrix  operator ! ();  // makes matrix inversion
   
     // Unary operators
   gmatrix operator + (); 
   gmatrix operator - ();
   gvet  operator % (const gvet &); // moltiplica una matrice (3,3) per un vettore gvet e restituisce un vettore gvet;
   
   
   
   
     // Combined assignment - calculation operators
   gmatrix& operator += (const gmatrix& m);
   gmatrix& operator -= (const gmatrix& m);
   gmatrix& operator *= (const gmatrix& m);
   gmatrix& operator *= (const double& c);
  
  
   
   gmatrix& operator ^= (const int& pow); //  matrix power
   
   friend gmatrix operator ^ (const gmatrix& m, const int & pow) 
{
   gmatrix temp = m;
   temp ^= pow;
   return temp;
};


   // Value extraction method  
   double& operator () (int row, int col); // Subscript operator
   int RowNo () const { return Row; }
   int ColNo () const { return Col; }

// dual operators 

   gmatrix  operator * (const gmatrix& m);
   gmatrix  operator * (const double& a);
   friend   gmatrix  operator * (const double& a, gmatrix& m){return m*a;};
   gmatrix  operator + (const gmatrix& m);
   gmatrix  operator - (const gmatrix& m);
   gmatrix& operator /= (const double& c){return *this*=(1./c);};
   gmatrix& operator /= (gmatrix& m){gmatrix temp= *this * !m;*this=temp;
                                     return *this;};

   gmatrix  operator / (gmatrix& m){return *this * !m;};
   gmatrix  operator / (const double& a) {return *this*(1./a);};
   friend   gmatrix  operator / (const double& a, gmatrix& m)
            {gmatrix temp= !m*a; return temp;};
            
//======================== operator end  ========================================            

  // Utility methods
   void Print(const char *);
   gmatrix Solve (const gmatrix& v) const;

   gmatrix Adj ();
   gmatrix Inv ();
   double Det () ;
 

private:
   double Norm ();
   // Type of matrices solo per sevizi interno...??(sonoi definite inline
   double Cofact (int row, int col);
   double Cond ();
   void Clone (const gmatrix&);
   int pivot (int row);

   bool IsSquare () { return (Row == Col); } 
   bool IsSingular ();
   bool IsDiagonal ();
   bool IsScalar ();
   bool IsUnit ();
   bool IsNull ();
   bool IsSymmetric ();
   bool IsSkewSymmetric ();
   bool IsUpperTriangular ();
   bool IsLowerTriangular ();
  };
  
// subscript operator to get/set individual elements
inline double & gmatrix::operator () (int r, int c) 
{
   if (r >= Row|| c >= Col)
   REPORT_ERROR(0,"gmatrix::operator(): Index out of range!");
//  cout<<"\n S/R "<<r<<" "<<c<<" "<<Elem<<endl;

   return ValM[r][c];
}
  inline void gmatrix::Reset() 
   {detrm=0.0;
    okflag=0;
    for (int i=0;i<Row;i++) 
    for (int j=0;j<Col;j++) 
    ValM[i][j]=0.0;
  }


#endif