BlockMatrixBase.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_BLOCKMATRIX_HPP
#define BOGUS_BLOCKMATRIX_HPP

#include "IterableBlockObject.hpp"

namespace bogus
{

template < typename Derived >
class BlockMatrixBase : public IterableBlockObject< Derived >
{
public:
    typedef BlockMatrixTraits< Derived > Traits ;
    typedef typename Traits::Index     Index ;
    typedef typename Traits::Scalar    Scalar ;

    // Supplemental Traits interface for BlockMatrixBase
    typedef typename Traits::BlockType       BlockType ;
    typedef typename Traits::BlockPtr        BlockPtr ;
    typedef typename Traits::BlocksArrayType BlocksArrayType ;

    typedef IterableBlockObject< Derived > Base;
    using Base::derived ;

    static const BlockPtr InvalidBlockPtr ;

    BlockMatrixBase() : m_rows(0), m_cols(0)
    {}

    virtual ~BlockMatrixBase()
    {}


    template < typename RhsT, typename ResT >
    void splitRowMultiply( const Index row, const RhsT& rhs, ResT& res ) const
    {
        derived().splitRowMultiply( row, rhs, res ) ;
    }

    BlockPtr blockPtr( Index row, Index col ) const
    {
        return derived().blockPtr( row, col ) ;
    }
    BlockPtr diagonalBlockPtr( Index row  ) const
    {
        return derived().diagonalBlockPtr( row ) ;
    }

    const BlockType& block( BlockPtr ptr ) const
    {
        return derived().block(ptr) ;
    }
    BlockType& block( BlockPtr ptr )
    {
        return derived().block(ptr) ;
    }

    Index rows() const { return m_rows ; }
    Index cols() const { return m_cols ; }

    Index size() const ;

    const typename Traits::BlocksArrayType& blocks() const { return  m_blocks ; }
    const BlockType* data() const { return  data_pointer(m_blocks) ; }
    BlockType* data() { return data_pointer(m_blocks) ; }

    BlockType& diagonal( const Index row )
    { return block( diagonalBlockPtr( row ) ) ; }
    const BlockType& diagonal( const Index row ) const
    { return block( diagonalBlockPtr( row ) ) ; }

    BlockType& block( Index row, Index col )
    { return block( blockPtr( row, col ) ) ; }
    const BlockType& block( Index row, Index col ) const
    { return block( blockPtr( row, col ) ) ; }


    template <typename Func>
    void eachBlockOfRow( const Index row, Func func ) const
    { derived().template eachBlockOf<false, Func>(row, func) ; }

    template <typename Func>
    void eachBlockOfCol( const Index col, Func func ) const
    { derived().template eachBlockOf<true ,Func>(col, func) ; }

    enum CompileTimeProperties
    {
        RowsPerBlock = Traits::RowsPerBlock,
        ColsPerBlock = Traits::ColsPerBlock,
        has_row_major_blocks = BlockTraits< BlockType >::is_row_major,
        has_square_or_dynamic_blocks = ColsPerBlock == RowsPerBlock,
        has_fixed_rows_blocks = ((int) RowsPerBlock != internal::DYNAMIC ),
        has_fixed_cols_blocks = ((int) ColsPerBlock != internal::DYNAMIC ),
        has_fixed_size_blocks = has_fixed_cols_blocks && has_fixed_rows_blocks
    } ;

protected:
    Index m_rows ;
    Index m_cols ;

    BlocksArrayType m_blocks ;
} ;

}

#endif // BLOCKMATRIX_HPP