TAPsSparseVector_Matrix3x3.cpp

Go to the documentation of this file.

/******************************************************************************
TAPsSparseVector_Matrix3x3.cpp
******************************************************************************/
/******************************************************************************
SUKITTI PUNAK   (12/22/2009)
UPDATE          (04/10/2009)
******************************************************************************/
#include "TAPsSparseVector_Matrix3x3.hpp"
// Using Inclusion Model (i.e. definitions are included in declarations)
//                       (this name.cpp is included in name.hpp)
// Each friend is defined directly inside its declaration.

BEGIN_NAMESPACE_TAPs
//=============================================================================
// Constructors
//-----------------------------------------------------------------------------
template <typename T>
SparseVector_Matrix3x3<T>::SparseVector_Matrix3x3 ( unsigned int size )
    : m_List( size )
{}
//-----------------------------------------------------------------------------
template <typename T>
SparseVector_Matrix3x3<T>::SparseVector_Matrix3x3 ( SparseVector_Matrix3x3<T> const &orig )
{
    m_List = orig.m_List;
}
//-----------------------------------------------------------------------------
template <typename T>
SparseVector_Matrix3x3<T>::~SparseVector_Matrix3x3 ()
{

}
//-----------------------------------------------------------------------------
template <typename T>
std::string SparseVector_Matrix3x3<T>::StrInfo () const
{
    std::ostringstream ss;
    ss << "SparseVector_Matrix3x3<" << typeid(T).name() << "> has " << m_List.size() << " elements:\n";
    std::list< SparseVector_Matrix3x3_ElementData<T> >::const_iterator it = m_List.begin();
    while ( it != m_List.end() ) {
        ss << "idx:"<<it->idx<<"\t"<< it->M << "\n";
        ++it;
    }
    return ss.str();
}
//-----------------------------------------------------------------------------

//=============================================================================
// Assignment Operator
//-----------------------------------------------------------------------------
template <typename T>
SparseVector_Matrix3x3<T> & SparseVector_Matrix3x3<T>::operator= ( SparseVector_Matrix3x3<T> const &orig )
{   
    m_List = orig.m_List;
    return *this;
}
//-----------------------------------------------------------------------------
template <typename T>
void SparseVector_Matrix3x3<T>::SetTo ( SparseVector_Matrix3x3<T> const &orig )
{   
    assert( m_List.size() == orig.m_List.size() );
    std::list< SparseVector_Matrix3x3_ElementData<T> >::const_iterator A = orig.m_List.begin();
    std::list< SparseVector_Matrix3x3_ElementData<T> >::iterator B = m_List.begin();
    while ( B != m_List.end() ) {
        B->M[0] = A->M[0];
        B->M[1] = A->M[1];
        B->M[2] = A->M[2];
        B->M[3] = A->M[3];
        B->M[4] = A->M[4];
        B->M[5] = A->M[5];
        B->M[6] = A->M[6];
        B->M[7] = A->M[7];
        B->M[8] = A->M[8];
        ++A;
        ++B;
    }
}
//-----------------------------------------------------------------------------
//=============================================================================

//=============================================================================
// Assignment Operator
//-----------------------------------------------------------------------------
template <typename T>
bool SparseVector_Matrix3x3<T>::Insert ( unsigned int index, Matrix3x3<T> const &M )
{
    std::list< SparseVector_Matrix3x3_ElementData<T> >::iterator it = m_List.begin();
    while( it != m_List.end() ) {
        if ( it->idx >= index ) {
            if ( it->idx == index ) return false;
            m_List.insert( it, SparseVector_Matrix3x3_ElementData<T>( index, M ) );
            return true;
        }
        ++it;
    }
    m_List.push_back( SparseVector_Matrix3x3_ElementData<T>( index, M ) );
    return true;
}
//-----------------------------------------------------------------------------

//=============================================================================
// Operations
//-----------------------------------------------------------------------------
template <typename T>
Vector3<T> SparseVector_Matrix3x3<T>::Mul (
    std::vector< Vector3<T> > const &V  // input: a dense vector
) const
{
    Vector3<T> O;
    std::list< SparseVector_Matrix3x3_ElementData<T> >::const_iterator it = m_List.begin();
    while ( it != m_List.end() ) {
        O += it->M * V[it->idx];
        ++it;
    }
    return O;
}
//template <typename T>
//Vector3<T> SparseVector_Matrix3x3<T>::MulForFEM_wSkippedElements (
//  std::vector< Vector3<T> > const &V, // input: a dense vector
//  std::vector< bool > const &Skip     //!< input: list of skipped rows
//) const
//{
//  Vector3<T> O;
//  std::list< SparseVector_Matrix3x3_ElementData<T> >::const_iterator it = m_List.begin();
//  while ( it != m_List.end() ) {
//      if ( Skip[it->idx] == false ) {
//          O += it->M * V[it->idx];
//      }
//      ++it;
//  }
//  return O;
//}
//-----------------------------------------------------------------------------
template <typename T>
void SparseVector_Matrix3x3<T>::MulForSparseSymmetricMatrix (
    unsigned int r,                 // input: the row of the sparse matrix that this vector is from
    std::vector< Vector3<T> > const &I, // input: a dense vector
    std::vector< Vector3<T> >       &O  // output: a dense vector
) const
{
    std::list< SparseVector_Matrix3x3_ElementData<T> >::const_iterator it = m_List.begin();
    O[r] += it->M * I[r];
    ++it;
    while ( it != m_List.end() ) {
        //O[r] += it->M * I[it->idx];
        O[r][0] += it->M[0]*I[it->idx][0] + it->M[1]*I[it->idx][1] + it->M[2]*I[it->idx][2];
        O[r][1] += it->M[3]*I[it->idx][0] + it->M[4]*I[it->idx][1] + it->M[5]*I[it->idx][2];
        O[r][2] += it->M[6]*I[it->idx][0] + it->M[7]*I[it->idx][1] + it->M[8]*I[it->idx][2];
        //O[it->idx] += it->M.GetTranspose() * I[r];
        O[it->idx][0] += it->M[0]*I[r][0] + it->M[3]*I[r][1] + it->M[6]*I[r][2];
        O[it->idx][1] += it->M[1]*I[r][0] + it->M[4]*I[r][1] + it->M[7]*I[r][2];
        O[it->idx][2] += it->M[2]*I[r][0] + it->M[5]*I[r][1] + it->M[8]*I[r][2];
        ++it;
    }
}
//-----------------------------------------------------------------------------
template <typename T>
void SparseVector_Matrix3x3<T>::UpdateAdd ( unsigned int index, Matrix3x3<T> const &M )
{
    std::list< SparseVector_Matrix3x3_ElementData<T> >::iterator it = m_List.begin();
    while( it != m_List.end() ) {
        if ( it->idx >= index ) {
            // Update the data
            if ( it->idx == index ) {
                it->M += M;
            }
            // Insert the data into the list
            else {
                m_List.insert( it, SparseVector_Matrix3x3_ElementData<T>( index, M ) );
            }
            return;
        }
        ++it;
    }
    // Add as the first element
    m_List.push_back( SparseVector_Matrix3x3_ElementData<T>( index, M ) );
}
//-----------------------------------------------------------------------------
template <typename T>
bool SparseVector_Matrix3x3<T>::Remove ( unsigned int index )
{
    std::list< Data_xyz<T> >::iterator it = m_List.begin();
    while( it != m_List.end() ) {
        if ( it->idx == index ) {
            m_List.erase( it );
            return true;
        }
        ++it;
    }
    return false;
}
//-----------------------------------------------------------------------------
template <typename T>
bool SparseVector_Matrix3x3<T>::SetData ( unsigned int index, Matrix3x3<T> const &M )
{
    std::list< Data_xyz<T> >::iterator it = m_List.begin();
    while( it != m_List.end() ) {
        if ( it->idx == index ) {
            it->M = M;
            return true;
        }
        ++it;
    }
    return false;
}
//-----------------------------------------------------------------------------
template <typename T>
Matrix3x3<T> * SparseVector_Matrix3x3<T>::ReturnMatrix3x3 ( unsigned int index )
{
    std::list< SparseVector_Matrix3x3_ElementData<T> >::iterator it = m_List.begin();
    while( it != m_List.end() ) {
        if ( it->idx == index ) {
            return &(it->M);
        }
        ++it;
    }
    return NULL;
}
//-----------------------------------------------------------------------------
template <typename T>
Matrix3x3<T> const * SparseVector_Matrix3x3<T>::ReturnMatrix3x3 ( unsigned int index ) const
{
    std::list< SparseVector_Matrix3x3_ElementData<T> >::const_iterator it = m_List.begin();
    while( it != m_List.end() ) {
        if ( it->idx == index ) {
            return &(it->M);
        }
        ++it;
    }
    return NULL;
}
//-----------------------------------------------------------------------------
template <typename T>
unsigned int SparseVector_Matrix3x3<T>::NumOfElements () const
{
    return m_List.size();
}
//-----------------------------------------------------------------------------
template <typename T>
std::list< SparseVector_Matrix3x3_ElementData<T> > const &
SparseVector_Matrix3x3<T>::RefToElements () const
{
    return m_List;
}
//-----------------------------------------------------------------------------
template <typename T>
std::list< SparseVector_Matrix3x3_ElementData<T> > &
SparseVector_Matrix3x3<T>::RefToElements ()
{
    return m_List;
}
//-----------------------------------------------------------------------------
//=============================================================================

//=============================================================================
END_NAMESPACE_TAPs
//34567890123456789012345678901234567890123456789012345678901234567890123456789
//--+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----