hyb_matrix.h

Go to the documentation of this file.

/*
 *  Copyright 2008-2014 NVIDIA Corporation
 *
 *  Licensed under the Apache License, Version 2.0 (the "License");
 *  you may not use this file except in compliance with the License.
 *  You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 *  Unless required by applicable law or agreed to in writing, software
 *  distributed under the License is distributed on an "AS IS" BASIS,
 *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 *  See the License for the specific language governing permissions and
 *  limitations under the License.
 */
 
#pragma once
 
#include <cusp/detail/config.h>
 
#include <cusp/array1d.h>
#include <cusp/detail/format.h>
#include <cusp/detail/matrix_base.h>
#include <cusp/detail/type_traits.h>
 
namespace cusp
{
 
// Forward definitions
template <typename IndexType, typename ValueType, class MemorySpace> class ell_matrix;
template <typename IndexType, typename ValueType, class MemorySpace> class coo_matrix;
template <typename MatrixType1, typename MatrixType2, typename IndexType, typename ValueType, class MemorySpace> class hyb_matrix_view;
template <typename IndexType, typename ValueType, class MemorySpace>
class hyb_matrix : public cusp::detail::matrix_base<IndexType,ValueType,MemorySpace,cusp::hyb_format>
{
private:
 
    typedef cusp::detail::matrix_base<IndexType,ValueType,MemorySpace,cusp::hyb_format> Parent;
 
public:
 
    typedef cusp::ell_matrix<IndexType,ValueType,MemorySpace> ell_matrix_type;
    typedef cusp::coo_matrix<IndexType,ValueType,MemorySpace> coo_matrix_type;
 
    typedef typename cusp::hyb_matrix<IndexType, ValueType, MemorySpace> container;
 
    typedef typename cusp::hyb_matrix_view<
            typename cusp::ell_matrix<IndexType,ValueType,MemorySpace>::view,
            typename cusp::coo_matrix<IndexType,ValueType,MemorySpace>::view,
            IndexType, ValueType, MemorySpace> view;
 
    typedef typename cusp::hyb_matrix_view<
            typename cusp::ell_matrix<IndexType,ValueType,MemorySpace>::const_view,
            typename cusp::coo_matrix<IndexType,ValueType,MemorySpace>::const_view,
            IndexType, ValueType, MemorySpace> const_view;
 
    typedef typename cusp::detail::coo_view_type<typename coo_matrix_type::row_indices_array_type,
                                                 typename coo_matrix_type::column_indices_array_type,
                                                 typename coo_matrix_type::values_array_type,
                                                 cusp::hyb_format>::view       coo_view_type;
    typedef typename cusp::detail::coo_view_type<typename coo_matrix_type::row_indices_array_type,
                                                 typename coo_matrix_type::column_indices_array_type,
                                                 typename coo_matrix_type::values_array_type,
                                                 cusp::hyb_format>::view       const_coo_view_type;
 
    template<typename MemorySpace2>
    struct rebind
    {
        typedef cusp::hyb_matrix<IndexType, ValueType, MemorySpace2> type;
    };
    ell_matrix_type ell;
 
    coo_matrix_type coo;
 
    hyb_matrix(void) {}
 
    hyb_matrix(IndexType num_rows, IndexType num_cols,
               IndexType num_ell_entries, IndexType num_coo_entries,
               IndexType num_entries_per_row, IndexType alignment = 32)
        : Parent(num_rows, num_cols, num_ell_entries + num_coo_entries),
          ell(num_rows, num_cols, num_ell_entries, num_entries_per_row, alignment),
          coo(num_rows, num_cols, num_coo_entries) {}
 
    // TODO remove default alignment of 32
 
    template <typename MatrixType>
    hyb_matrix(const MatrixType& matrix);
 
    void resize(IndexType num_rows, IndexType num_cols,
                IndexType num_ell_entries, IndexType num_coo_entries,
                IndexType num_entries_per_row, IndexType alignment = 32)
    {
        Parent::resize(num_rows, num_cols, num_ell_entries + num_coo_entries);
        ell.resize(num_rows, num_cols, num_ell_entries, num_entries_per_row, alignment);
        coo.resize(num_rows, num_cols, num_coo_entries);
    }
 
    void swap(hyb_matrix& matrix)
    {
        Parent::swap(matrix);
        ell.swap(matrix.ell);
        coo.swap(matrix.coo);
    }
 
    template <typename MatrixType>
    hyb_matrix& operator=(const MatrixType& matrix);
 
}; // class hyb_matrix
template <typename MatrixType1,
         typename MatrixType2,
         typename IndexType   = typename MatrixType1::index_type,
         typename ValueType   = typename MatrixType1::value_type,
         typename MemorySpace = typename cusp::minimum_space<typename MatrixType1::memory_space, typename MatrixType2::memory_space>::type >
class hyb_matrix_view : public cusp::detail::matrix_base<IndexType,ValueType,MemorySpace,cusp::hyb_format>
{
private:
 
    typedef cusp::detail::matrix_base<IndexType,ValueType,MemorySpace,cusp::hyb_format> Parent;
 
public:
 
    typedef MatrixType1 ell_matrix_type;
    typedef MatrixType2 coo_matrix_type;
 
    typedef typename cusp::hyb_matrix<IndexType, ValueType, MemorySpace> container;
    typedef typename cusp::hyb_matrix_view<MatrixType1, MatrixType2, IndexType, ValueType, MemorySpace> view;
    typedef typename cusp::hyb_matrix_view<MatrixType1, MatrixType2, IndexType, ValueType, MemorySpace> const_view;
 
    typedef typename cusp::detail::coo_view_type<typename coo_matrix_type::row_indices_array_type,
                                                 typename coo_matrix_type::column_indices_array_type,
                                                 typename coo_matrix_type::values_array_type,
                                                 cusp::hyb_format>::view       coo_view_type;
    typedef typename cusp::detail::coo_view_type<typename coo_matrix_type::row_indices_array_type,
                                                 typename coo_matrix_type::column_indices_array_type,
                                                 typename coo_matrix_type::values_array_type,
                                                 cusp::hyb_format>::view       const_coo_view_type;
    ell_matrix_type ell;
 
    coo_matrix_type coo;
 
    hyb_matrix_view(void) {}
 
    template <typename OtherMatrixType1, typename OtherMatrixType2>
    hyb_matrix_view(OtherMatrixType1& ell, OtherMatrixType2& coo)
        : Parent(ell.num_rows, ell.num_cols, ell.num_entries + coo.num_entries), ell(ell), coo(coo) {}
 
    template <typename OtherMatrixType1, typename OtherMatrixType2>
    hyb_matrix_view(const OtherMatrixType1& ell, const OtherMatrixType2& coo)
        : Parent(ell.num_rows, ell.num_cols, ell.num_entries + coo.num_entries), ell(ell), coo(coo) {}
 
    hyb_matrix_view(hyb_matrix<IndexType,ValueType,MemorySpace>& matrix)
        : Parent(matrix), ell(matrix.ell), coo(matrix.coo) {}
 
    hyb_matrix_view(const hyb_matrix<IndexType,ValueType,MemorySpace>& matrix)
        : Parent(matrix), ell(matrix.ell), coo(matrix.coo) {}
 
    hyb_matrix_view(hyb_matrix_view& matrix)
        : Parent(matrix), ell(matrix.ell), coo(matrix.coo) {}
 
    hyb_matrix_view(const hyb_matrix_view& matrix)
        : Parent(matrix), ell(matrix.ell), coo(matrix.coo) {}
 
    void resize(size_t num_rows, size_t num_cols,
                size_t num_ell_entries, size_t num_coo_entries,
                size_t num_entries_per_row, size_t alignment = 32);
};
} // end namespace cusp
 
#include <cusp/detail/hyb_matrix.inl>