mi32/mimatrix.h

Go to the documentation of this file.

#ifndef  INC_MI32_MIMATRIX_H
#define  INC_MI32_MIMATRIX_H

#ifndef INC_MI32_DOUBLEAR_H
#include <mi32/doublear.h>
#endif

#ifdef GEOMDLL
   #define CLASSEXPORT MI_DLLCLASSEXPORT
#else
   #define CLASSEXPORT MI_DLLCLASSIMPORT
#endif

class CLASSEXPORT MIMATRIX {
   public:

      MIMATRIX ();

      MIMATRIX (const MIMATRIX& rhs);

      ~MIMATRIX ();

      MIMATRIX& operator= (const MIMATRIX& rhs);

      MIMATRIX& operator*= (
         double value
         ) { MultiplyScalar(value); return (*this); }

      MIMATRIX& operator/= (
         double value
         ) { MultiplyScalar(1.0/value); return (*this); }

      const MIMATRIX operator- (
         ) { return (MIMATRIX(OP_Negate,*this)); }

      void Add (
         UINT32 row,
         UINT32 col,
         double value
         );

      ERRVALUE Add (
         const MIMATRIX& matrix
         );

      void AddScalar (
         double value
         );

      double ComputeConditionNumber (
         ) const;

      double ComputeDeterminant (
         ) const;

      ERRVALUE ComputeEigen (
         MIMATRIX& EigenVectors,       
         MIMATRIX& EigenValues         
         ) const;

      ERRVALUE ComputeInverse (
         MIMATRIX& result,             
         UINT32 MaxIterations = 0,     
         double MaxError = 0
         ) const;

      double ComputeMaxAbsolute (
         ) const;

      ERRVALUE ComputePseudoInverse (
         MIMATRIX& result,             
         double tolerance = 0          
         ) const;

      ERRVALUE ComputeSVD (
         MIMATRIX& U,                  
         MIMATRIX& W,                  
         MIMATRIX& V                   
         ) const;

      double ComputeTrace (
         ) const;

      ERRVALUE Create (
         UINT32 Rows,                  
         UINT32 Cols,                  
         const double *values = 0      
         );

      ERRVALUE CreateDiagonal (
         UINT32 Size,                  
         double value                  
         );

      ERRVALUE CreateDiagonal (
         const MIMATRIX& vector        
         );

      ERRVALUE CreateProduct (
         const MIMATRIX& left,         
         const MIMATRIX& right         
         );

      ERRVALUE GetDiagonal (
         MIMATRIX& result              
         ) const;

      UINT32 GetNumColumns (
         ) const { return (m_Cols); }

      UINT32 GetNumElements (
         ) const { return (m_values.GetNumItems()); }

      UINT32 GetNumRows (
         ) const { return (m_Rows); }

      double GetValueFast (
         UINT32 row,                   
         UINT32 col                    
         ) const { return (m_values[static_cast<int>(row*m_Cols+col)]); }

      double GetValueValidated (
         UINT32 row,                   
         UINT32 col                    
         ) const;

      double GetValueFast (
         UINT32 num                    
         ) const { return (m_values[static_cast<int>(num)]); }

      double GetValueValidated (
         UINT32 num                    
         ) const;

      void GetValues (
         double *values                
         ) const;

      bool IsEqual (
         const MIMATRIX& matrix,
         double tolerance = 0
         ) const;

      bool IsDiagonal (
         double tolerance = 0
         ) const;

      bool IsSameSize (
         const MIMATRIX& matrix
         ) const { return (m_Rows == matrix.m_Rows && m_Cols == matrix.m_Cols); }

      bool IsSingular (
         ) const;

      bool IsSymmetric (
         double tolerance = 0
         ) const;

      bool IsVector (
         ) const { return (m_Rows == 1 || m_Cols == 1); }

      ERRVALUE MultiplyLeft (
         const MIMATRIX& left
         );

      ERRVALUE MultiplyRight (
         const MIMATRIX& right
         );

      void MultiplyScalar (
         double value
         );

      ERRVALUE ReplaceSubMatrix (
         UINT32 TgtStartRow,           
         UINT32 TgtStartCol,           
         const MIMATRIX& SrcMatrix,    
         UINT32 SrcStartRow = 0,       
         UINT32 SrcStartCol = 0,       
         UINT32 NumRows = 0,           
         UINT32 NumCols = 0            
         );

      ERRVALUE Resize (
         UINT32 Rows,
         UINT32 Cols
         );

      void RotateClockwise (
         );

      void SetScalar (
         double value
         );

      void SetIdentity (
         );

      void SetValueFast (
         UINT32 row,
         UINT32 col,
         double value
         ) { m_values[static_cast<int>(row*m_Cols+col)] = value; }

      void SetValueValidated (
         UINT32 row,
         UINT32 col,
         double value
         );

      void SetValueFast (
         UINT32 num,                   
         double value
         ) { m_values[static_cast<int>(num)] = value; }

      void SetValueValidated (
         UINT32 num,                   
         double value
         );

      void SetZero (
         ) { m_values.ClearItems(); }

      ERRVALUE SolveLinear (
         const MIMATRIX& A,            
         const MIMATRIX& B,            
         double tolerance = 0          
         );

      ERRVALUE SolveLinearSVD (
         const MIMATRIX& U,            
         const MIMATRIX& W,            
         const MIMATRIX& V,            
         const MIMATRIX& B,
         double tolerance = 0          
         );

      ERRVALUE Subtract (
         const MIMATRIX& matrix
         );

      void Swap (
         MIMATRIX& other               
         );

      void Transpose (
         );

      #ifndef GENERATING_DOXYGEN_OUTPUT

      enum OP {
         OP_Add,
         OP_Subtract,
         OP_Multiply,
         OP_Negate
         };

      // Algebraic constructor used by binary operators to facilitate Return Value Optimization.
      MIMATRIX (
         OP op,
         const MIMATRIX& lhs,
         const MIMATRIX& rhs
         );

      // Algebraic constructor used by binary operators to facilitate Return Value Optimization.
      MIMATRIX (
         OP op,
         const MIMATRIX& lhs,
         double rhs = 0
         );

   private:

      DOUBLE_ARRAY<double> m_values;
      UINT32 m_Rows;
      UINT32 m_Cols;

      // Access vector element (const).
      const double& element (
         UINT32 num
         ) const { return (m_values[static_cast<int>(num)]); }

      // Access vector element (non-const).
      double& element (
         UINT32 num
         ) { return (m_values[static_cast<int>(num)]); }

      // Access element (const).
      const double& element (
         UINT32 row,
         UINT32 col
         ) const { return (m_values[static_cast<int>(row*m_Cols+col)]); }

      // Access element (non-const).
      double& element (
         UINT32 row,
         UINT32 col
         ) { return (m_values[static_cast<int>(row*m_Cols+col)]); }

      ERRVALUE HouseholderReduction (MIMATRIX& E, MIMATRIX& D);
      ERRVALUE QLImplicit (MIMATRIX& E, MIMATRIX& D);

      #endif   // GENERATING_DOXYGEN_OUTPUT
   };


inline const MIMATRIX operator+ (
   const MIMATRIX& lhs,
   const MIMATRIX& rhs
   ) { return (MIMATRIX(MIMATRIX::OP_Add,lhs,rhs)); }

inline const MIMATRIX operator- (
   const MIMATRIX& lhs,
   const MIMATRIX& rhs
   ) { return (MIMATRIX(MIMATRIX::OP_Subtract,lhs,rhs)); }

inline const MIMATRIX operator* (
   const MIMATRIX& lhs,
   const MIMATRIX& rhs
   ) { return (MIMATRIX(MIMATRIX::OP_Multiply,lhs,rhs)); }

inline const MIMATRIX operator* (
   const MIMATRIX& lhs,
   double rhs
   ) { return (MIMATRIX(MIMATRIX::OP_Multiply,lhs,rhs)); }

inline const MIMATRIX operator/ (
   const MIMATRIX& lhs,
   double rhs
   ) { return (MIMATRIX(MIMATRIX::OP_Multiply,lhs,1.0/rhs)); }

inline const MIMATRIX operator* (
   double lhs,
   const MIMATRIX& rhs
   ) { return (MIMATRIX(MIMATRIX::OP_Multiply,rhs,lhs)); }


#undef CLASSEXPORT

#endif   // INC_MI32_MIMATRIX_H 

---