BlockObjectBase.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_BLOCKOBJECTBASE_HPP
#define BOGUS_BLOCKOBJECTBASE_HPP

#include "../Block.fwd.hpp"

namespace bogus
{

template < typename Derived >
struct BlockObjectBase
{
    const Derived& derived() const
    {
        return static_cast< const Derived& >( *this ) ;
    }
    Derived& derived()
    {
        return static_cast< Derived& >( *this ) ;
    }

    typedef BlockMatrixTraits< Derived > Traits ;

    typedef typename Traits::Index Index ;
    typedef typename Traits::Scalar Scalar ;
    typedef typename Traits::ConstTransposeReturnType ConstTransposeReturnType ;
    typedef typename Traits::TransposeObjectType TransposeObjectType ;
    enum { is_transposed = Traits::is_transposed } ;

    typedef typename Traits::PlainObjectType PlainObjectType ;

    Index rows() const { return derived().rows() ; }
    Index cols() const { return derived().cols() ; }

    Index blockRows( Index row ) const { return derived().blockRows( row ) ; }
    Index blockCols( Index col ) const { return derived().blockCols( col ) ; }

    Index rowsOfBlocks() const { return derived().rowsOfBlocks() ; }
    Index colsOfBlocks() const { return derived().colsOfBlocks() ; }

    const Index *rowOffsets( ) const { return derived().rowOffsets( ) ; }
    const Index *colOffsets( ) const { return derived().colOffsets( ) ; }

    Index rowOffset( Index row ) const { return rowOffsets()[ row ] ; }
    Index colOffset( Index col ) const { return colOffsets()[ col ] ; }

    ConstTransposeReturnType transpose() const { return derived().transpose() ; }


    template < bool DoTranspose, typename RhsT, typename ResT >
    void multiply( const RhsT& rhs, ResT& res, Scalar alpha = 1, Scalar beta = 0 ) const
    {
        derived().template multiply< DoTranspose >( rhs, res, alpha, beta ) ;
    }

    // To use as block type
    enum {
        RowsAtCompileTime = internal::DYNAMIC,
        ColsAtCompileTime = internal::DYNAMIC,
        is_self_transpose = Traits::is_symmetric
    } ;
};


template< typename Derived  >
struct BlockMatrixTraits< BlockObjectBase< Derived > > {

    typedef BOGUS_DEFAULT_INDEX_TYPE Index ;

    typedef Transpose< Derived >  TransposeObjectType ;

    typedef TransposeObjectType   ConstTransposeReturnType ;

    enum {
        is_symmetric  = 0,  
        is_transposed = 0,  
        is_temporary  = 0   
    } ;

    enum {
        RowsPerBlock = internal::DYNAMIC,
        ColsPerBlock = internal::DYNAMIC
    };

    typedef Derived                  PlainObjectType ;
} ;

}

#endif // BLOCKMATRIX_HPP