densematrix.h

Go to the documentation of this file.

#ifndef _DENSE_MATRIX_H_
#define _DENSE_MATRIX_H_

#include <map>
#include <vector>
#include <complex>


namespace MeshLib
{
        
        double _inner_product( double * v1, double *v2, int num )
        {
                double sum = 0;
                for( int i = 0; i < num; i ++ )
                {
                        sum += v1[i] * v2[i];
                }
                return sum;
        };

        void _scale( double * v, double s, int num )
        {
                for( int i = 0; i < num; i ++ )
                {
                        v[i] *= s;
                }
        };

        double norm( double * v, int num )
        {
                double inner_product = _inner_product( v,v, num );
                return sqrt( inner_product );   
        };

        void _normalize( double * v, int num )
        {
                double mag = norm( v, num );
                                
                for( int i = 0; i < num; i ++ )
                {
                        v[i] /= mag;
                };
        };


        class CDenseMatrix
        {
        public:
                CDenseMatrix( int row, int col )
                {
                        m_row = row;
                        m_col = col;
                        
                        m_ptr = new double*[m_row];
                        assert( m_ptr );

                        for( int i = 0 ; i < m_row ; i ++ )
                        {
                                m_ptr[i] = new double[m_col];
                                assert( m_ptr[i] );
                        };

                        reset();
                };

                ~CDenseMatrix()
                {
                        for( int i = 0 ; i < m_row ; i ++ )
                        {
                                delete m_ptr[i];
                        };

                        delete m_ptr;
                };

                double * operator[]( int idx ){ assert(0<= idx && idx < m_row ); return m_ptr[idx]; };
                
                void reset();

                void Gram_Schmidt_Orghonomralization();
                
                int  row() { return m_row; };
                int  col() { return m_col; };

        protected:

                int m_row;
                int m_col;

                double ** m_ptr;

        };

inline void CDenseMatrix::Gram_Schmidt_Orghonomralization()
{
        for( int i = 0; i < m_row; i ++ )
        {
                for( int j = 0; j < i; j ++ )
                {
                        double inner = _inner_product( m_ptr[i], m_ptr[j], m_col );
                        
                        for( int k = 0; k < m_col; k ++ )
                        {
                                m_ptr[i][k] = m_ptr[i][k] - m_ptr[j][k] * inner; 
                        }
                }

                _normalize( m_ptr[i], m_col );
                if( i % 150 == 0 )
                        printf("%d/%d\n", i, m_row );

        };
};

inline void CDenseMatrix::reset()
{
        for( int i = 0; i < m_row; i ++ )
        {
                for( int j = 0; j < m_col; j ++ )
                {
                                m_ptr[i][j] = 0; 
                }
        };
};

};
#endif