MappedSparseBlockMatrix.hpp

/*
 * This file is part of bogus, a C++ sparse block matrix library.
 *
 * Copyright 2013 Gilles Daviet <gdaviet@gmail.com>
 *
 * This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/.
*/


#ifndef BOGUS_MAPPED_SPARSEBLOCKMATRIX_HPP
#define BOGUS_MAPPED_SPARSEBLOCKMATRIX_HPP

#include "CompressedSparseBlockIndex.hpp"
#include "SparseBlockMatrixBase.hpp"
#include "../Utils/CppTools.hpp"

namespace bogus
{

template < typename BlockT, int Flags, typename Index_ >
struct BlockMatrixTraits< MappedSparseBlockMatrix< BlockT, Flags, Index_ > >
        : public BlockMatrixTraits< BlockObjectBase< MappedSparseBlockMatrix< BlockT, Flags, Index_ > > >
{
    typedef BlockMatrixTraits< BlockObjectBase< MappedSparseBlockMatrix< BlockT, Flags, Index_ > > > BaseTraits ;
    typedef typename BaseTraits::Index   Index;
    typedef typename BlockTraits< BlockT >::Scalar Scalar ;

    enum {
        is_symmetric  =  !!(  Flags & flags::SYMMETRIC    ),
        RowsPerBlock = BlockTraits< BlockT >::RowsAtCompileTime,
        ColsPerBlock = BlockTraits< BlockT >::ColsAtCompileTime
    } ;

    typedef BlockT BlockType ;
    typedef BOGUS_DEFAULT_BLOCK_PTR_TYPE BlockPtr ;
    typedef typename ConstMappedArray< BlockType >::Type BlocksArrayType ;

    enum {
        is_compressed  = 1,
        is_col_major   = !!( Flags & flags::COL_MAJOR ),
        flags          = Flags & ~flags::UNCOMPRESSED
    } ;

    typedef SparseBlockIndex< is_compressed, Index, BlockPtr, ConstMappedArray > MajorIndexType ;

} ;


template < typename BlockT, int Flags, typename Index_ >
class MappedSparseBlockMatrix : public  SparseBlockMatrixBase< MappedSparseBlockMatrix< BlockT, Flags, Index_ > >
{
public:
    typedef SparseBlockMatrixBase< MappedSparseBlockMatrix > Base ;
    typedef typename Base::Index    Index ;
    typedef typename Base::BlockPtr BlockPtr ;

    MappedSparseBlockMatrix() : Base()
    {
    }

    template < typename Derived >
    explicit MappedSparseBlockMatrix( const SparseBlockMatrixBase< Derived > &source ) : Base()
    {
        mapTo( source ) ;
    }

    void mapTo(
            std::size_t numberOfNonZeros,    
            const BlockT* dataPtr,           
            const Index*  outerIndexPtr,     
            const Index*  innerIndexPtr      
            )
    {
        Base::clear() ;

        Base::m_blocks.setData( dataPtr, numberOfNonZeros ) ;
        Base::m_majorIndex.inner.setData( innerIndexPtr, numberOfNonZeros ) ;
        Base::m_majorIndex.outer.setData( outerIndexPtr, Base::m_minorIndex.innerSize() + 1 ) ;

        Base::m_minorIndex.valid = Base::empty() ;
        Base::Finalizer::finalize( *this ) ;
    }

    template < typename Derived >
    void mapTo( const SparseBlockMatrixBase< Derived > &source )
    {
        BOGUS_STATIC_ASSERT( (int) Base::Traits::flags == (int) Derived::Traits::flags,
                             OPERANDS_HAVE_INCONSISTENT_FLAGS ) ;

        Base::cloneDimensions( source ) ;
        mapTo( source.nBlocks(),
               source.data(),
               source.majorIndex().outerIndexPtr(),
               source.majorIndex().innerIndexPtr()
               );

    }

} ;

// Specialization for block matrix of MappedSparseBlockMatrix
template < typename BlockT, int Flags, typename Index_ >
struct BlockTraits< MappedSparseBlockMatrix< BlockT, Flags, Index_ > >
{
    typedef MappedSparseBlockMatrix< BlockT, Flags, Index_ > BlockType ;
    typedef typename BlockType::Scalar Scalar ;
    typedef MappedSparseBlockMatrix
        < typename BlockType::TransposeBlockType, Flags ^ flags::COL_MAJOR, Index_ >
        TransposeStorageType ;

    enum {
        RowsAtCompileTime = internal::DYNAMIC,
        ColsAtCompileTime = internal::DYNAMIC,
        uses_plain_array_storage = 0,
        is_row_major = !BlockMatrixTraits< BlockType >::is_col_major,
        is_self_transpose = BlockMatrixTraits< BlockType >::is_symmetric
    }  ;
} ;

}

#endif // SPARSEBLOCKMATRIX_HH