Array.h

Go to the documentation of this file.

#ifndef included_AMP_ArrayClass
#define included_AMP_ArrayClass
 
#include "AMP/utils/ArraySize.h"
#include "AMP/utils/FunctionTable.h"
#include "AMP/utils/Memory.h"
 
#include <array>
#include <cstddef>
#include <functional>
#include <initializer_list>
#include <iostream>
#include <memory>
#include <string>
#include <vector>
 
 
namespace AMP {
 
 
template<class TYPE, class FUN, class Allocator>
class Array final
{
public: // Typedefs
    typedef TYPE value_type;
    typedef FUN function_table;
    static_assert( !std::is_same_v<TYPE, std::vector<bool>::reference> );
    static_assert( std::is_same_v<typename FUN::value_type, TYPE> );
    static_assert( std::is_same_v<typename Allocator::value_type, void> ||
                   std::is_same_v<typename Allocator::value_type, TYPE> );
    using scalarAllocator_t =
        typename std::allocator_traits<Allocator>::template rebind_alloc<TYPE>;
 
public: // Constructors / assignment operators
    Array();
 
    explicit Array( const ArraySize &N, const TYPE *data = nullptr );
 
    explicit Array( size_t N );
 
    explicit Array( size_t N_rows, size_t N_columns );
 
    explicit Array( size_t N1, size_t N2, size_t N3 );
 
    explicit Array( size_t N1, size_t N2, size_t N3, size_t N4 );
 
    explicit Array( size_t N1, size_t N2, size_t N3, size_t N4, size_t N5 );
 
    template<typename U = TYPE, typename = typename std::enable_if<std::is_same_v<U, TYPE>>::type>
    explicit Array( const Range<U> &range );
 
    explicit Array( std::string range );
 
    Array( std::initializer_list<TYPE> data );
 
    Array( std::initializer_list<std::initializer_list<TYPE>> data );
 
 
    Array( const Array &rhs );
 
    Array( Array &&rhs );
 
    Array &operator=( const Array &rhs );
 
    Array &operator=( Array &&rhs );
 
    Array &operator=( const std::vector<TYPE> &rhs );
 
    ARRAY_INLINE bool isCopyable() const { return d_isCopyable; }
 
    ARRAY_INLINE void setCopyable( bool flag ) { d_isCopyable = flag; }
 
    ARRAY_INLINE bool isFixedSize() const { return d_isFixedSize; }
 
    ARRAY_INLINE void setFixedSize( bool flag ) { d_isFixedSize = flag; }
 
    ~Array();
 
 
public: // Views/copies/subset
    static std::unique_ptr<Array> view( const ArraySize &N, std::shared_ptr<TYPE> data );
 
 
    static std::unique_ptr<const Array> constView( const ArraySize &N,
                                                   const std::shared_ptr<const TYPE> &data );
 
    Array<TYPE, FUN, Allocator> view();
 
 
    void view2( Array &src );
 
    void view2( const ArraySize &N, std::shared_ptr<TYPE> data );
 
    void viewRaw(
        int ndim, const size_t *dims, TYPE *data, bool isCopyable = true, bool isFixedSize = true )
    {
        viewRaw( ArraySize( ndim, dims ), data, isCopyable, isFixedSize );
    }
 
    void viewRaw( const ArraySize &N, TYPE *data, bool isCopyable = true, bool isFixedSize = true )
    {
        d_isCopyable  = isCopyable;
        d_isFixedSize = isFixedSize;
        d_ptr.reset();
        d_size = N;
        d_data = data;
    }
 
    static Array staticView( const ArraySize &N, TYPE *data )
    {
        Array x;
        x.viewRaw( N, data, true, true );
        return x;
    }
 
    template<class TYPE2>
    static inline auto convert( std::shared_ptr<Array<TYPE, FUN, Allocator>> array )
    {
        using FUN2 = typename FUN::template cloneTo<TYPE2>;
        static_assert( std::is_same_v<typename FUN2::value_type, TYPE2> );
        using ARRAY2 = Array<TYPE2, FUN2, Allocator>;
        auto array2  = std::make_unique<ARRAY2>( array->size() );
        array2.copy( *array );
        return array2;
    }
 
 
    template<class TYPE2>
    static inline auto convert( std::shared_ptr<const Array<TYPE, FUN, Allocator>> array )
    {
        using FUN2 = typename FUN::template cloneTo<TYPE2>;
        static_assert( std::is_same_v<typename FUN2::value_type, TYPE2> );
        using ARRAY2 = Array<TYPE2, FUN2, Allocator>;
        auto array2  = std::make_unique<ARRAY2>( array->size() );
        array2.copy( *array );
        return array2;
    }
 
 
    template<class TYPE2, class FUN2, class Allocator2>
    void inline copy( const Array<TYPE2, FUN2, Allocator2> &array )
    {
        resize( array.size() );
        copy( array.data() );
    }
 
    template<class TYPE2>
    inline void copy( const TYPE2 *data );
 
    template<class TYPE2>
    inline void copyTo( TYPE2 *data ) const;
 
    template<class TYPE2>
    inline auto cloneTo() const
    {
        using FUN2 = typename FUN::template cloneTo<TYPE2>;
        static_assert( std::is_same_v<typename FUN2::value_type, TYPE2> );
        Array<TYPE2, FUN2, AMP::HostAllocator<void>> dst( this->size() );
        copyTo( dst.data() );
        return dst;
    }
 
 
    template<class TYPE2>
    inline auto reinterpretArray() const
    {
        static_assert( sizeof( TYPE ) == sizeof( TYPE2 ) );
        auto ptr   = std::reinterpret_pointer_cast<TYPE2>( std::const_pointer_cast<TYPE>( d_ptr ) );
        using FUN2 = typename FUN::template cloneTo<TYPE2>;
        static_assert( std::is_same_v<typename FUN2::value_type, TYPE2> );
        Array<TYPE2, FUN2, Allocator> y;
        y.view2( d_size, ptr );
        return y;
    }
 
 
    void swap( Array &other );
 
 
    ARRAY_INLINE void fill( const TYPE &y )
    {
        for ( auto &x : *this )
            x = y;
    }
 
    void scale( const TYPE &y );
 
 
    void pow( const Array &base, const TYPE &exp );
 
 
    void clear();
 
 
    ARRAY_INLINE int ndim() const { return d_size.ndim(); }
 
 
    ARRAY_INLINE const ArraySize &size() const { return d_size; }
 
 
    ARRAY_INLINE size_t size( int d ) const { return d_size[d]; }
 
 
    ARRAY_INLINE size_t length() const { return d_size.length(); }
 
 
    ARRAY_INLINE bool empty() const { return d_size.length() == 0; }
 
 
    ARRAY_INLINE operator bool() const { return d_size.length() != 0; }
 
 
    void resize( size_t N );
 
 
    void resize( size_t N_row, size_t N_col );
 
    void resize( size_t N1, size_t N2, size_t N3 );
 
    void resize( const ArraySize &N );
 
 
    void resizeDim( int dim, size_t N, const TYPE &value );
 
 
    void reshape( const ArraySize &N );
 
 
    ARRAY_INLINE void setNdim( int ndim ) { d_size.setNdim( ndim ); }
 
 
    Array subset( const std::vector<size_t> &index ) const;
 
 
    Array subset( const std::vector<Range<size_t>> &index ) const;
 
 
    void copySubset( const std::vector<size_t> &index, const Array &subset );
 
    void copySubset( const std::vector<Range<size_t>> &index, const Array &subset );
 
    void addSubset( const std::vector<size_t> &index, const Array &subset );
 
    void addSubset( const std::vector<Range<size_t>> &index, const Array &subset );
 
 
public: // Accessors
    ARRAY_INLINE TYPE &operator()( size_t i ) { return d_data[d_size.index( i )]; }
 
    ARRAY_INLINE const TYPE &operator()( size_t i ) const { return d_data[d_size.index( i )]; }
 
    ARRAY_INLINE TYPE &operator()( size_t i, size_t j ) { return d_data[d_size.index( i, j )]; }
 
    ARRAY_INLINE const TYPE &operator()( size_t i, size_t j ) const
    {
        return d_data[d_size.index( i, j )];
    }
 
    ARRAY_INLINE TYPE &operator()( size_t i, size_t j, size_t k )
    {
        return d_data[d_size.index( i, j, k )];
    }
 
    ARRAY_INLINE const TYPE &operator()( size_t i, size_t j, size_t k ) const
    {
        return d_data[d_size.index( i, j, k )];
    }
 
    ARRAY_INLINE TYPE &operator()( size_t i1, size_t i2, size_t i3, size_t i4 )
    {
        return d_data[d_size.index( i1, i2, i3, i4 )];
    }
 
    ARRAY_INLINE const TYPE &operator()( size_t i1, size_t i2, size_t i3, size_t i4 ) const
    {
        return d_data[d_size.index( i1, i2, i3, i4 )];
    }
 
    ARRAY_INLINE TYPE &operator()( size_t i1, size_t i2, size_t i3, size_t i4, size_t i5 )
    {
        return d_data[d_size.index( i1, i2, i3, i4, i5 )];
    }
 
    ARRAY_INLINE const TYPE &
    operator()( size_t i1, size_t i2, size_t i3, size_t i4, size_t i5 ) const
    {
        return d_data[d_size.index( i1, i2, i3, i4, i5 )];
    }
 
    ARRAY_INLINE TYPE &operator[]( size_t i ) { return d_data[i]; }
 
    ARRAY_INLINE const TYPE &operator[]( size_t i ) const { return d_data[i]; }
 
 
    ARRAY_INLINE TYPE *ptr( size_t i ) { return i >= d_size.length() ? nullptr : &d_data[i]; }
 
    ARRAY_INLINE const TYPE *ptr( size_t i ) const
    {
        return i >= d_size.length() ? nullptr : &d_data[i];
    }
 
    ARRAY_INLINE TYPE *begin() { return d_data; }
 
    ARRAY_INLINE const TYPE *begin() const { return d_data; }
 
    ARRAY_INLINE TYPE *end() { return d_data + d_size.length(); }
 
    ARRAY_INLINE const TYPE *end() const { return d_data + d_size.length(); }
 
    std::shared_ptr<TYPE> getPtr() { return d_ptr; }
 
    std::shared_ptr<const TYPE> getPtr() const { return d_ptr; }
 
    ARRAY_INLINE TYPE *data() { return d_data; }
 
    ARRAY_INLINE const TYPE *data() const { return d_data; }
 
 
public: // Operator overloading
    // Equality means the dimensions and data have to be identical
    bool operator==( const Array &rhs ) const;
 
    bool operator!=( const Array &rhs ) const;
 
    Array &operator+=( const Array &rhs );
 
    Array &operator-=( const Array &rhs );
 
    Array &operator+=( const TYPE &rhs );
 
    Array &operator-=( const TYPE &rhs );
 
 
public: // Math operations
    static Array cat( const std::vector<Array> &x, int dim = 0 );
 
    static Array cat( const std::initializer_list<Array> &x, int dim = 0 );
 
    static Array cat( size_t N_array, const Array *x, int dim );
 
    void cat( const Array &x, int dim = 0 );
 
    void rand();
 
    bool NaNs() const;
 
    TYPE min() const;
 
    TYPE max() const;
 
    TYPE sum() const;
 
    TYPE mean() const;
 
    Array min( int dir ) const;
 
    Array max( int dir ) const;
 
    Array sum( int dir ) const;
 
    TYPE min( const std::vector<size_t> &index ) const;
 
    TYPE max( const std::vector<size_t> &index ) const;
 
    TYPE sum( const std::vector<size_t> &index ) const;
 
    TYPE mean( const std::vector<size_t> &index ) const;
 
    TYPE min( const std::vector<Range<size_t>> &index ) const;
 
    TYPE max( const std::vector<Range<size_t>> &index ) const;
 
    TYPE sum( const std::vector<Range<size_t>> &index ) const;
 
    TYPE mean( const std::vector<Range<size_t>> &index ) const;
 
    std::vector<size_t> find( const TYPE &value,
                              std::function<bool( const TYPE &, const TYPE & )> compare ) const;
 
    int64_t findFirst( const TYPE &value,
                       std::function<bool( const TYPE &, const TYPE & )> compare ) const;
 
    int64_t findLast( const TYPE &value,
                      std::function<bool( const TYPE &, const TYPE & )> compare ) const;
 
    void
    print( std::ostream &os, const std::string &name = "A", const std::string &prefix = "" ) const;
 
    Array reverseDim() const;
 
    Array repmat( const ArraySize &N ) const;
 
    Array coarsen( const Array &filter ) const;
 
    Array coarsen( const ArraySize &ratio, std::function<TYPE( const Array & )> filter ) const;
 
    static Array transform( std::function<TYPE( const TYPE & )> fun, const Array &x );
 
    static Array transform( std::function<TYPE( const TYPE &, const TYPE & )> fun,
                            const Array &x,
                            const Array &y );
 
    void axpby( const TYPE &alpha, const Array &x, const TYPE &beta );
 
    inline TYPE interp( const std::vector<double> &x ) const { return interp( x.data() ); }
 
    TYPE interp( const double *x ) const;
 
    bool equals( const Array &rhs, const TYPE &tol = 0.000001 ) const;
 
public:
    size_t packSize() const;
    size_t pack( std::byte * ) const;
    size_t unpack( const std::byte * );
 
private:
    scalarAllocator_t d_alloc;
    bool d_isCopyable;           // Can the array be copied
    bool d_isFixedSize;          // Can the array be resized
    ArraySize d_size;            // Size of each dimension
    TYPE *d_data;                // Raw pointer to data in array
    std::shared_ptr<TYPE> d_ptr; // Shared pointer to data in array
    void allocate( const ArraySize &N );
 
private:
    inline void checkSubsetIndex( const std::vector<Range<size_t>> &range ) const;
    inline std::vector<Range<size_t>> convert( const std::vector<size_t> &index ) const;
    static inline void getSubsetArrays( const std::vector<Range<size_t>> &range,
                                        std::array<size_t, 5> &first,
                                        std::array<size_t, 5> &last,
                                        std::array<size_t, 5> &inc,
                                        std::array<size_t, 5> &N );
 
private:
    class Deleter
    {
    public:
        Deleter( const scalarAllocator_t &alloc, size_t N ) : d_alloc( alloc ), d_N( N ) {}
        void operator()( TYPE *p )
        {
            if constexpr ( !std::is_trivially_copyable<TYPE>::value ) {
                for ( size_t i = 0; i < d_N; ++i )
                    p[i].~TYPE();
            }
            d_alloc.deallocate( p, d_N );
        }
 
    private:
        scalarAllocator_t d_alloc;
        size_t d_N;
    };
};
 
 
/********************************************************
 *  ostream operator                                     *
 ********************************************************/
inline std::ostream &operator<<( std::ostream &out, const AMP::ArraySize &s )
{
    out << "[" << s[0];
    for ( size_t i = 1; i < s.ndim(); i++ )
        out << "," << s[i];
    out << "]";
    return out;
}
template<class TYPE>
inline std::ostream &operator<<( std::ostream &out, const AMP::Range<TYPE> &r )
{
    out << r.i << ':' << r.k << ':' << r.j;
    return out;
}
 
 
/********************************************************
 *  Math operations                                      *
 ********************************************************/
template<class TYPE, class FUN, class Allocator>
inline Array<TYPE, FUN, Allocator> operator+( const Array<TYPE, FUN, Allocator> &a,
                                              const Array<TYPE, FUN, Allocator> &b )
{
    auto c = a;
    c += b;
    return c;
}
template<class TYPE, class FUN, class Allocator>
inline Array<TYPE, FUN, Allocator> operator-( const Array<TYPE, FUN, Allocator> &a,
                                              const Array<TYPE, FUN, Allocator> &b )
{
    auto c = a;
    c -= b;
    return c;
}
template<class TYPE, class FUN, class Allocator>
inline Array<TYPE, FUN, Allocator> operator*( const Array<TYPE, FUN, Allocator> &a,
                                              const Array<TYPE, FUN, Allocator> &b )
{
    Array<TYPE, FUN, Allocator> c( multiplySize( a.size(), b.size() ) );
    FUN::multiply( a.size(), a.data(), b.size(), b.data(), c.size(), c.data() );
    return c;
}
template<class TYPE, class FUN, class Allocator>
inline Array<TYPE, FUN, Allocator> operator*( const Array<TYPE, FUN, Allocator> &a,
                                              const std::vector<TYPE> &b )
{
    Array<TYPE, FUN, Allocator> b2;
    b2.viewRaw( { b.size() }, const_cast<TYPE *>( b.data() ) );
    Array<TYPE, FUN, Allocator> c( multiplySize( a.size(), b.size() ) );
    FUN::multiply( a.size(), a.data(), b2.size(), b2.data(), c.size(), c.data() );
    return c;
}
template<class TYPE, class FUN, class Allocator>
inline Array<TYPE, FUN, Allocator> operator*( const TYPE &a, const Array<TYPE, FUN, Allocator> &b )
{
    auto c = b;
    c.scale( a );
    return c;
}
template<class TYPE, class FUN, class Allocator>
inline Array<TYPE, FUN, Allocator> operator*( const Array<TYPE, FUN, Allocator> &a, const TYPE &b )
{
    auto c = a;
    c.scale( b );
    return c;
}
 
 
/********************************************************
 *  Copy array                                           *
 ********************************************************/
template<class TYPE, class FUN, class Allocator>
template<class TYPE2>
inline void AMP::Array<TYPE, FUN, Allocator>::copy( const TYPE2 *data )
{
    if constexpr ( std::is_same_v<TYPE, TYPE2> ) {
        std::copy( data, data + d_size.length(), d_data );
    } else {
        for ( size_t i = 0; i < d_size.length(); i++ )
            d_data[i] = static_cast<TYPE>( data[i] );
    }
}
template<class TYPE, class FUN, class Allocator>
template<class TYPE2>
inline void AMP::Array<TYPE, FUN, Allocator>::copyTo( TYPE2 *data ) const
{
    if constexpr ( std::is_same_v<TYPE, TYPE2> ) {
        std::copy( d_data, d_data + d_size.length(), data );
    } else {
        for ( size_t i = 0; i < d_size.length(); i++ )
            data[i] = static_cast<TYPE2>( d_data[i] );
    }
}
 
 
} // namespace AMP
 
 
#endif