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/memory.h>
#include <cusp/detail/format.h>
#include <cusp/array1d.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 typename 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 typename cusp::array1d<ValueType, MemorySpace> values_array_type;
    typedef typename cusp::array2d<ValueType, MemorySpace, Orientation> container;

    typedef typename cusp::array2d_view<typename values_array_type::view, Orientation> view;
    typedef typename cusp::array2d_view<typename values_array_type::const_view, Orientation> const_view;

    typedef cusp::detail::row_or_column_view<
    typename values_array_type::iterator,thrust::detail::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,thrust::detail::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,thrust::detail::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,thrust::detail::is_same<Orientation,cusp::column_major>::value>
    const_column_view_type;

    typedef typename const_column_view_type::ArrayType const_column_view;
    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);

}; // 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 typename cusp::array2d<typename Parent::value_type, typename Parent::memory_space, Orientation> container;

    typedef typename cusp::array2d_view<ArrayView, Orientation> view;

    typedef cusp::detail::row_or_column_view<
    typename values_array_type::iterator,thrust::detail::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,thrust::detail::is_same<Orientation,cusp::column_major>::value> column_view_type;
    typedef typename column_view_type::ArrayType column_view;
    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;
}; // 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>