array1d.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/exception.h>

#include <cusp/iterator/random_iterator.h>

#include <thrust/copy.h>
#include <thrust/host_vector.h>
#include <thrust/device_vector.h>
#include <thrust/detail/vector_base.h>
#include <thrust/iterator/constant_iterator.h>
#include <thrust/iterator/counting_iterator.h>

namespace cusp
{

// forward declaration of array1d_view
template <typename RandomAccessIterator> class array1d_view;

template <typename T, typename MemorySpace>
class array1d : public thrust::detail::vector_base<T, typename cusp::default_memory_allocator<T, MemorySpace>::type>
{
private:
    typedef typename cusp::default_memory_allocator<T, MemorySpace>::type Alloc;
    typedef typename thrust::detail::vector_base<T,Alloc>                 Parent;

public:
    typedef MemorySpace                                 memory_space;
    typedef cusp::array1d_format                        format;

    typedef typename Parent::iterator                   iterator;
    typedef typename Parent::const_iterator             const_iterator;
    typedef typename Parent::value_type                 value_type;
    typedef typename Parent::size_type                  size_type;

    typedef cusp::array1d<T,MemorySpace>                container;
    typedef typename cusp::array1d_view<iterator>       view;
    typedef typename cusp::array1d_view<const_iterator> const_view;

    template<typename MemorySpace2>
    struct rebind {
        typedef cusp::array1d<T, MemorySpace2> type;
    };
    array1d(void)
      : Parent() {}

    explicit array1d(size_type n)
        : Parent(n) {}

    explicit array1d(size_type n, const value_type &value)
        : Parent(n, value) {}

    array1d(const array1d &v)
        : Parent(v) {}

    array1d &operator=(const array1d &v)
    { Parent::operator=(v); return *this; }

    template<typename OtherT, typename OtherMem>
    array1d(const array1d<OtherT, OtherMem> &v)
        : Parent(v) {}

    template<typename OtherT, typename OtherMem>
    array1d &operator=(const array1d<OtherT, OtherMem> &v)
    { Parent::operator=(v); return *this; }

    template<typename OtherT, typename OtherAlloc>
    array1d(const std::vector<OtherT, OtherAlloc> &v)
        : Parent(v) {}

    template<typename OtherT, typename OtherAlloc>
    array1d &operator=(const std::vector<OtherT, OtherAlloc> &v)
    { Parent::operator=(v); return *this; }

    template<typename OtherT, typename OtherAlloc>
    array1d(const thrust::host_vector<OtherT, OtherAlloc> &v)
        : Parent(v) {}

    template<typename OtherT, typename OtherAlloc>
    array1d &operator=(const thrust::host_vector<OtherT, OtherAlloc> &v)
    { Parent::operator=(v); return *this; }

    template<typename OtherT, typename OtherAlloc>
    array1d(const thrust::device_vector<OtherT, OtherAlloc> &v)
        : Parent(v) {}

    template<typename OtherT, typename OtherAlloc>
    array1d &operator=(const thrust::device_vector<OtherT, OtherAlloc> &v)
    { Parent::operator=(v); return *this; }

    template<typename InputIterator>
    array1d(InputIterator first, InputIterator last)
        : Parent(first, last) {}

    template<typename InputIterator>
    array1d(const array1d_view<InputIterator> &v)
        : Parent(v.begin(), v.end()) {}

    view subarray(size_type start_index, size_type num_entries);

    const_view subarray(size_type start_index, size_type num_entries) const;

}; // end class array1d
template<typename RandomAccessIterator>
class array1d_view : public thrust::iterator_adaptor<array1d_view<RandomAccessIterator>, RandomAccessIterator>
{
private :
    typedef thrust::iterator_adaptor<array1d_view<RandomAccessIterator>, RandomAccessIterator> Parent;

    friend class thrust::iterator_core_access;

public :

    typedef RandomAccessIterator                                                iterator;
    typedef cusp::array1d_format                                                format;

    typedef typename thrust::iterator_value<RandomAccessIterator>::type         value_type;
    typedef typename thrust::iterator_system<RandomAccessIterator>::type        memory_space;
    typedef typename thrust::iterator_pointer<RandomAccessIterator>::type       pointer;
    typedef typename thrust::iterator_reference<RandomAccessIterator>::type     reference;
    typedef typename thrust::iterator_difference<RandomAccessIterator>::type    difference_type;
    // typedef typename thrust::iterator_difference<RandomAccessIterator>::type    size_type;
    typedef size_t                                                              size_type;

    typedef typename cusp::array1d<value_type,memory_space>                     container;

    // TODO: Fixed view types, view == const_view???
    typedef typename cusp::array1d_view<RandomAccessIterator>                   view;

    typedef RandomAccessIterator                                                const_iterator;
    typedef typename cusp::array1d_view<const_iterator>                         const_view;
    array1d_view(void)
        : m_size(0), m_capacity(0) {}

    template<typename ArrayType>
    array1d_view(ArrayType &v)
        : Parent(v.begin()), m_size(v.size()), m_capacity(v.capacity()) {}

    template<typename InputIterator>
    array1d_view(InputIterator begin, InputIterator end)
        : Parent(begin), m_size(end-begin), m_capacity(end-begin) {}

    array1d_view &operator=(const array1d_view& v);

    reference front(void) const;

    reference back(void) const;

    reference operator[](size_type n) const;

    iterator begin(void) const;

    iterator end(void) const;

    size_type size(void) const;

    size_type capacity(void) const;

    // Thrust does not export iterator pointer types so data is not valid
    // see http://thrust.github.io/doc/classthrust_1_1iterator__facade.html
    // pointer data(void)
    // {
    //     return &front();
    // }

    void resize(size_type new_size);

    view subarray(size_type start_index, size_type num_entries);


    void swap(array1d_view &v);

protected:
    size_type m_size;

    size_type m_capacity;
};

template <typename ValueType>
class counting_array
    : public cusp::array1d_view< thrust::counting_iterator<ValueType> >
{
private:

    typedef cusp::array1d_view< thrust::counting_iterator<ValueType> > Parent;

public:

    typedef typename Parent::iterator  iterator;
    typedef typename Parent::size_type size_type;
    counting_array(size_type size, ValueType init = ValueType(0))
        : Parent(iterator(init), iterator(init) + size) {}
};

template <typename ValueType>
class constant_array
    : public cusp::array1d_view< thrust::constant_iterator<ValueType> >
{
private:

    typedef cusp::array1d_view< thrust::constant_iterator<ValueType> > Parent;

public:

    typedef typename Parent::iterator iterator;
    typedef typename Parent::size_type size_type;
    constant_array(size_type size, ValueType value)
        : Parent(iterator(value), iterator(value) + size) {}
};

template <typename ValueType>
class random_array :
  public cusp::array1d_view< typename cusp::random_iterator<ValueType>::iterator >
{
private:

    typedef cusp::array1d_view< typename cusp::random_iterator<ValueType>::iterator > Parent;

public:

    typedef typename cusp::random_iterator<ValueType> rand;
    typedef typename Parent::size_type size_type;
    random_array(size_type size, size_type seed = 0)
        : Parent(rand(seed).begin(), rand(seed).begin() + size) {}
};


template <typename Iterator>
array1d_view<Iterator> make_array1d_view(Iterator first, Iterator last)
{
    array1d_view<Iterator> view(first, last);

    return view;
}

template <typename T, typename MemorySpace>
typename array1d<T,MemorySpace>::view make_array1d_view(array1d<T,MemorySpace>& v)
{
    return make_array1d_view(v.begin(), v.end());
}

template <typename Iterator>
typename array1d_view<Iterator>::view make_array1d_view(array1d_view<Iterator>& v)
{
    return make_array1d_view(v.begin(), v.end());
}

template <typename Iterator>
typename array1d_view<Iterator>::view make_array1d_view(const array1d_view<Iterator>& v)
{
    return make_array1d_view(v.begin(), v.end());
}

template <typename T, typename MemorySpace>
typename array1d<T,MemorySpace>::const_view make_array1d_view(const array1d<T,MemorySpace>& v)
{
    return make_array1d_view(v.begin(), v.end());
}
} // end namespace cusp

#include <cusp/detail/array1d.inl>