array2d.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/detail/format.h>
 
#include <cusp/array1d.h>
#include <cusp/memory.h>
 
#include <cusp/detail/array2d_format_utils.h>
#include <cusp/detail/matrix_base.h>
 
#include <thrust/functional.h>
 
namespace cusp
{
 
// TODO document mapping of (i,j) onto values[pitch * i + j] or values[pitch * j + i]
// TODO document that array2d operations will try to respect .pitch of destination argument
 
template<typename ValueType, typename MemorySpace, typename Orientation = cusp::row_major>
class array2d : public cusp::detail::matrix_base<int,ValueType,MemorySpace,cusp::array2d_format>
{
private:
 
    typedef cusp::detail::matrix_base<int,ValueType,MemorySpace,cusp::array2d_format> Parent;
 
public:
    typedef Orientation orientation;
 
    template<typename MemorySpace2>
    struct rebind {
        typedef cusp::array2d<ValueType, MemorySpace2, Orientation> type;
    };
 
    typedef cusp::array1d<ValueType, MemorySpace> values_array_type;
    typedef cusp::array2d<ValueType, MemorySpace, Orientation> container;
 
    typedef cusp::array2d_view<typename values_array_type::view, Orientation> view;
    typedef cusp::array2d_view<typename values_array_type::const_view, Orientation> const_view;
 
    typedef cusp::detail::row_or_column_view<
        typename values_array_type::iterator,::cuda::std::is_same<Orientation,cusp::row_major>::value
      > row_view_type;
 
    typedef typename row_view_type::ArrayType row_view;
 
    typedef cusp::detail::row_or_column_view<
        typename values_array_type::iterator,::cuda::std::is_same<Orientation,cusp::column_major>::value
      > column_view_type;
 
    typedef typename column_view_type::ArrayType column_view;
 
    typedef cusp::detail::row_or_column_view<
        typename values_array_type::const_iterator,::cuda::std::is_same<Orientation,cusp::row_major>::value
      > const_row_view_type;
 
    typedef typename const_row_view_type::ArrayType const_row_view;
 
    typedef cusp::detail::row_or_column_view<
        typename values_array_type::const_iterator,::cuda::std::is_same<Orientation,cusp::column_major>::value
      > const_column_view_type;
 
    typedef typename const_column_view_type::ArrayType const_column_view;
 
    typedef typename cusp::detail::transpose_orientation<Orientation>::type transpose_orientation;
    typedef cusp::array2d_view<typename values_array_type::const_view, transpose_orientation> transpose_const_view_type;
    size_t pitch;
 
    values_array_type values;
 
    array2d(void)
        : Parent(), pitch(0), values(0) {}
 
    array2d(size_t num_rows, size_t num_cols)
        : Parent(num_rows, num_cols, num_rows * num_cols),
          pitch(cusp::detail::minor_dimension(num_rows, num_cols, orientation())),
          values(num_rows * num_cols) {}
 
    array2d(size_t num_rows, size_t num_cols, const ValueType& value)
        : Parent(num_rows, num_cols, num_rows * num_cols),
          pitch(cusp::detail::minor_dimension(num_rows, num_cols, orientation())),
          values(num_rows * num_cols, value) {}
 
    array2d(const size_t num_rows, const size_t num_cols, const ValueType& value, const size_t pitch);
 
    template <typename MatrixType>
    array2d(const MatrixType& matrix);
 
    typename values_array_type::reference operator()(const size_t i, const size_t j);
 
    typename values_array_type::const_reference operator()(const size_t i, const size_t j) const;
 
    void resize(const size_t num_rows, const size_t num_cols);
 
    void resize(const size_t num_rows, const size_t num_cols, const size_t pitch);
 
    void swap(array2d& matrix);
 
    row_view row(const size_t i);
 
    column_view column(const size_t i);
 
    const_row_view row(const size_t i) const;
 
    const_column_view column(const size_t i) const;
 
    array2d& operator=(const array2d& matrix);
 
    template <typename MatrixType>
    array2d& operator=(const MatrixType& matrix);
 
    transpose_const_view_type T(void) const;
 
}; // class array2d
template<typename ArrayView, class Orientation = cusp::row_major>
class array2d_view
    : public cusp::detail::matrix_base<int,
                                       typename ArrayView::value_type,
                                       typename ArrayView::memory_space,
                                       cusp::array2d_format>
{
private:
 
    typedef cusp::detail::matrix_base<int,
                                      typename ArrayView::value_type,
                                      typename ArrayView::memory_space,
                                      cusp::array2d_format> Parent;
 
public:
 
    typedef Orientation orientation;
 
    typedef ArrayView values_array_type;
 
    typedef cusp::array2d<typename Parent::value_type, typename Parent::memory_space, Orientation> container;
 
    typedef cusp::array2d_view<ArrayView, Orientation> view;
 
    typedef cusp::detail::row_or_column_view<
        typename values_array_type::iterator,::cuda::std::is_same<Orientation,cusp::row_major>::value
      > row_view_type;
    typedef typename row_view_type::ArrayType row_view;
 
    typedef cusp::detail::row_or_column_view<
        typename values_array_type::iterator,::cuda::std::is_same<Orientation,cusp::column_major>::value
      > column_view_type;
    typedef typename column_view_type::ArrayType column_view;
 
    typedef typename cusp::detail::transpose_orientation<Orientation>::type transpose_orientation;
    typedef cusp::array2d_view<ArrayView, transpose_orientation> transpose_const_view_type;
    size_t pitch;
 
    values_array_type values;
 
    array2d_view(void)
        : Parent(), pitch(0), values(0) {}
 
    array2d_view(const array2d_view& a)
        : Parent(a), pitch(a.pitch), values(a.values) {}
 
    // TODO handle different Orientation (pitch = major)
    //template <typename Array2, typename Orientation2>
    //array2d_view(const array2d_view<Array2,Orientation2>& A)
 
    array2d_view(array2d<typename Parent::value_type, typename Parent::memory_space, orientation>& a)
        : Parent(a), pitch(a.pitch), values(a.values) {}
 
    template <typename Array2>
    array2d_view(size_t num_rows, size_t num_cols, size_t pitch, const Array2& values)
        : Parent(num_rows, num_cols, num_rows * num_cols), pitch(pitch), values(values) {}
 
    typename values_array_type::reference operator()(const size_t i, const size_t j) const;
 
    void resize(const size_t num_rows, const size_t num_cols);
 
    void resize(const size_t num_rows, const size_t num_cols, const size_t pitch);
 
    row_view row(size_t i);
 
    column_view column(size_t i);
 
    row_view row(size_t i) const;
 
    column_view column(size_t i) const;
 
    transpose_const_view_type T(void) const;
}; // end array2d_view class
 
 
template <typename Iterator, typename Orientation>
array2d_view<typename cusp::array1d_view<Iterator>,Orientation>
make_array2d_view(size_t num_rows, size_t num_cols, size_t pitch, const cusp::array1d_view<Iterator>& values, Orientation)
{
    return array2d_view<typename cusp::array1d_view<Iterator>,Orientation>(num_rows, num_cols, pitch, values);
}
 
template <typename Array, typename Orientation>
array2d_view<Array,Orientation>
make_array2d_view(const array2d_view<Array, Orientation>& v)
{
    return array2d_view<Array,Orientation>(v);
}
 
template<typename T, class MemorySpace, class Orientation>
array2d_view<typename cusp::array1d_view<typename cusp::array1d<T,MemorySpace>::iterator>, Orientation>
make_array2d_view(cusp::array2d<T,MemorySpace,Orientation>& v)
{
    return cusp::make_array2d_view(v.num_rows, v.num_cols, v.pitch, cusp::make_array1d_view(v.values), Orientation());
}
 
template<typename T, class MemorySpace, class Orientation>
array2d_view<typename cusp::array1d_view<typename cusp::array1d<T,MemorySpace>::const_iterator>, Orientation>
make_array2d_view(const cusp::array2d<T,MemorySpace,Orientation>& v)
{
    return cusp::make_array2d_view(v.num_rows, v.num_cols, v.pitch, cusp::make_array1d_view(v.values), Orientation());
}
} // end namespace cusp
 
#include <cusp/detail/array2d.inl>