ivl/details/array_nd/impl/specialization/array_nd_class.hpp

/* This file is part of the ivl C++ library <http://image.ntua.gr/ivl>.
   A C++ template library extending syntax towards mathematical notation.

   Copyright (C) 2012 Yannis Avrithis <iavr@image.ntua.gr>
   Copyright (C) 2012 Kimon Kontosis <kimonas@image.ntua.gr>

   ivl is free software; you can redistribute it and/or modify
   it under the terms of the GNU Lesser General Public License 
   version 3 as published by the Free Software Foundation.

   Alternatively, you can redistribute it and/or modify it under the terms 
   of the GNU General Public License version 2 as published by the Free 
   Software Foundation.

   ivl is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  
   See the GNU General Public License for more details.

   You should have received a copy of the GNU General Public License 
   and a copy of the GNU Lesser General Public License along 
   with ivl. If not, see <http://www.gnu.org/licenses/>. */



template <class T, class OPTS = mem>
class array_nd:
        public
        array_common_base<array_nd<T, OPTS> >,

        public
        array_nd_details::
                basic_iterator_nd_interface<array_nd<T, OPTS> >
{
private:
        typedef array_nd prv_this_type;
        typedef typename prv_this_type::common_base_class common_base_class;
        typedef typename prv_this_type::iter_nd_interface_class iter_nd_interface;

        size_t ndim;
        array<size_t, tiny> sizes;
        array<size_t, tiny> strides;

public:
        /*
        TODO: wipe these?
        operator common_base_class&() { return *this; }
        operator const common_base_class&() const { return *this; }
        operator common_base_class() { return *this; }
        operator const common_base_class() const { return *this; }
        */

        typedef array_nd this_type;

        typedef this_type this_array_nd_type;

        typedef typename common_base_class::derived_type derived_type;

        typedef typename common_base_class::base_class base_class;

        typedef this_type array_type;

        typedef array<size_t, tiny> size_type;

        typedef const array<size_t, tiny>& size_nd_ref_type;

        typedef const array<size_t, tiny>& stride_ref_type;

        typedef types::t_true has_1d_parenthesis;
        typedef types::t_true has_2d_parenthesis;
        typedef types::t_true has_3d_parenthesis;
        typedef types::t_true has_nd_parenthesis;

        typedef typename this_type::best_reference best_reference;
        typedef typename this_type::const_reference const_reference;

        // use _arg_base instead of _arg to solve weird msvc2005 bug
    typedef typename this_type::all_init_arg_base all_init_arg;
    typedef typename this_type::data_init_arg_base data_init_arg;

        using base_class::derived;

        base_class& base() { return *this; }
        const base_class& base() const { return *this; }

        using base_class::operator[];
        using base_class::length;
        using base_class::numel;

        using common_base_class::operator();

        best_reference operator()(size_t s1)
                { return (*this)[s1]; }
        best_reference operator()(size_t s1, size_t s2)
                { return (*this)[s1 + s2 * strides[1]]; }
        best_reference operator()(size_t s1, size_t s2, size_t s3)
                { return (*this)[s1 + s2 * strides[1] + s3 * strides[2]]; }
        best_reference operator()(size_t s1, size_t s2, size_t s3, size_t s4)
                {       return (*this)[s1 + s2 * strides[1] + s3 * strides[2] +
                        s4 * strides[3]]; }
        best_reference operator()(size_t s1, size_t s2, size_t s3, size_t s4,
                size_t s5)
                {       return (*this)[s1 + s2 * strides[1] + s3 * strides[2] +
                        s4 * strides[3] + s5 * strides[4]]; }
        best_reference operator()(size_t s1, size_t s2, size_t s3, size_t s4,
                size_t s5, size_t s6)
                {       return (*this)[s1 + s2 * strides[1] + s3 * strides[2] +
                        s4 * strides[3] + s5 * strides[4] + s6 * strides[5]]; }
        template<class S>
        best_reference operator()(const array<size_t, S>& indx)
                { return derived()[sub2ind(derived(), indx)]; }

        const_reference operator()(size_t s1) const
                { return (*this)[s1]; }
        const_reference operator()(size_t s1, size_t s2) const
                { return (*this)[s1 + s2 * strides[1]]; }
        const_reference operator()(size_t s1, size_t s2, size_t s3) const
                { return (*this)[s1 + s2 * strides[1] + s3 * strides[2]]; }
        const_reference operator()(size_t s1, size_t s2, size_t s3,
                size_t s4) const
                {       return (*this)[s1 + s2 * strides[1] + s3 * strides[2] +
                        s4 * strides[3]]; }
        const_reference operator()(size_t s1, size_t s2, size_t s3, size_t s4,
                size_t s5) const
                {       return (*this)[s1 + s2 * strides[1] + s3 * strides[2] +
                        s4 * strides[3] + s5 * strides[4]]; }
        const_reference operator()(size_t s1, size_t s2, size_t s3, size_t s4,
                size_t s5, size_t s6) const
                {       return (*this)[s1 + s2 * strides[1] + s3 * strides[2] +
                        s4 * strides[3] + s5 * strides[4] + s6 * strides[5]]; }
        template<class S>
        const_reference operator()(const array<size_t, S>& indx) const
                { return derived()[sub2ind(derived(), indx)]; }




        array_nd() : ndim(0), sizes(0), strides(0) { }

        explicit array_nd(size_t count)
        : common_base_class(count), ndim(1),
                sizes(size_array(1, count)), strides(size_array(1,1)) { };

        array_nd(size_t count, const T& s) :
                common_base_class(count, s), ndim(1),
                sizes(size_array(1, count)), strides(size_array(1,1)) { };

        template <class J, class D>
        array_nd(size_t count, const array<J, D>& s) :
                common_base_class(count, s), ndim(1),
                sizes(size_array(1, count)), strides(size_array(1,1)) { };

        array_nd(size_t count, const T *data) :
                common_base_class(count, data), ndim(1),
                sizes(size_array(1,count)), strides(size_array(1,1)) { };

        template<class S>
        array_nd(size_t count, const data_init_arg& y) :
                common_base_class(count, y), ndim(1),
                sizes(size_array(1,count)), strides(size_array(1,1)) { };


        template<class S>
        array_nd(const array<size_t, S>& sz) :
                common_base_class(size_t(prod(sz))), ndim(sz.length()),
                sizes(sz), strides(cumprod(shift(sz, 1, size_t(1)))) { };

        template<class S>
        array_nd(const array<size_t, S>& sz, const T& s) :
                common_base_class(prod(sz), s), ndim(sz.length()), sizes(sz),
                strides(cumprod(shift(sz, 1, size_t(1)))) { };

        template<class S>
        array_nd(const array<size_t, S>& sz, const T* ptr) :
                common_base_class(prod(sz), ptr), ndim(sz.length()),
                sizes(sz), strides(cumprod(shift(sz, 1, size_t(1)))) { };

        template<class S>
        array_nd(const array<size_t, S>& sz, const data_init_arg& y) :
                common_base_class(prod(sz), y), ndim(sz.length()),
                sizes(sz), strides(cumprod(shift(sz, 1, size_t(1)))) { };

        template<class S, class J, class D>
        array_nd(const array<size_t, S>& sz, const array<J, D>& a) :
                common_base_class(prod(sz), a),
                ndim(sz.length()), sizes(sz),
                strides(cumprod(shift(sz, 1, size_t(1)))) { };

        // specific for the case that we have ref iterator and we need non-const
        // array
        template<class S, class J, class D>
        array_nd(const array<size_t, S>& sz, array<J, D>& a) :
                common_base_class(prod(sz), a),
                ndim(sz.length()), sizes(sz),
                strides(cumprod(shift(sz, 1, size_t(1)))) { };

        array_nd(const this_type& a) :
                common_base_class(a),
                ndim(a.ndims()), sizes(a.size_nd()), strides(a.stride()) { };

        template<class J, class S>
        array_nd(const array_nd<J, S>& a) :
                common_base_class(a),
                ndim(a.ndims()), sizes(a.size_nd()),
                strides(a.stride()) { };

        template<class J, class S>
        array_nd(array_nd<J, S>& a) :
                common_base_class(a),
                ndim(a.ndims()), sizes(a.size_nd()),
                strides(a.stride()) { };

#ifdef IVL_MATLAB

        array_nd(const mxArray* mx);
#endif



        size_nd_ref_type size_nd() const { return sizes; }

        size_t size_nd(size_t d) const { return sizes[d]; }

        stride_ref_type stride() const { return strides; }

        size_t stride(size_t dim) const { return strides[dim]; }

        size_type size() const { return size_nd(); }

        size_t size(size_t d) const { return sizes[d]; }

        size_t ndims() const { return ndim; }
        using iter_nd_interface::first_to_last;
        using common_base_class::first_to_last;

        using iter_nd_interface::begin_to_end;
        using common_base_class::begin_to_end;








        void init(const size_t newsize, const T& s);

        void init(const size_t newsize);

        template <class S>
        void init(const array<size_t, S>& newsize, const T& s);

        template <class S>
        void init(const array<size_t, S>& newsize);
        //
        void resize(const size_t newsize, const T& s);

        void resize(const size_t newsize);

        template <class S>
        void resize(const array<size_t, S>& newsize, const T& s);

        template <class S>
        void resize(const array<size_t, S>& newsize);
//
        void reshape(const size_t newsize, const T& s);

        void reshape(const size_t newsize);

        template <class S>
        void reshape(const array<size_t, S>& newsize, const T& s);

        template <class S>
        void reshape(const array<size_t, S>& newsize);
        // Operators

/*
TODO: do something for this. you need to disable this operator for the array_nd,
since it is forbidden to resize the underlying array, that would cause data corruption.
this might possibly be handled with the derived mechanism and promote the return
value of this function to a non-resizable type when the Derived type is an
array_nd......

        static_indirect_array<T, false> operator[](const size_array& idx)
                { return static_indirect_array<T, false>(idx, this->base_ptr); }

        static_mask_array<T, false> operator[](const bool_array& idx)
                { return static_mask_array<T, false>(idx, this->get_base_ptr()); }
*/


        //using common_base_class::operator=;
        template<class K>
        derived_type& operator=(const K& k)
        { common_base_class::operator=(k); return derived(); }

        this_type& operator=(const this_type& in)
        { common_base_class::operator=(in); return *this; }

};


// init

template <class T, class D>
void array_nd<T, D>::init(size_t newsize)
// override the base data init because it will be now invalid.
{
        // call array data class init first
        base_class::init(newsize);

        ndim = 1;
        sizes.init(1, newsize);
        strides.init(1, 1);
}

template <class T, class D>
void array_nd<T, D>::init(size_t newsize, const T& s)
// override the base data init because it will be now invalid.
{
        // call array data class init first
        base_class::init(newsize, s);

        ndim = 1;
        sizes.init(1, newsize);
        strides.init(1, 1);
}

template <class T, class D>
template<class S>
void array_nd<T, D>::init(const array<size_t, S>& newsize)
{
        // call array data class init first
        base_class::init(prod(newsize));

        ndim = newsize.length();
        sizes = newsize;
        strides = cumprod<size_t>(shift(sizes, 1, size_t(1)));
}

template <class T, class D>
template<class S>
void array_nd<T, D>::init(const array<size_t, S>& newsize, const T& s)
{
        // call array data class init first
        base_class::init(prod(newsize), s);

        ndim = newsize.length();
        sizes = newsize;
        strides = cumprod<size_t>(shift(sizes, 1, size_t(1)));
}

// reshape

template <class T, class D>
void array_nd<T, D>::reshape(size_t newsize)
// override the base data resize because it will be now invalid.
{
        // call array data class resize first
        base_class::resize(newsize);

        ndim = 1;
        sizes.resize(1, newsize);
        strides.resize(1, 1);
}

template <class T, class D>
void array_nd<T, D>::reshape(size_t newsize, const T& s)
// override the base data resize because it will be now invalid.
{
        // call array data class resize first
        base_class::resize(newsize, s);

        ndim = 1;
        sizes.resize(1, newsize);
        strides.resize(1, 1);
}

template <class T, class D>
template<class S>
void array_nd<T, D>::reshape(const array<size_t, S>& newsize)
{
        // call array data class resize first
        base_class::resize(prod(newsize));

        ndim = newsize.length();
        sizes = newsize;
        strides = cumprod<size_t>(shift(sizes, 1, size_t(1)));
}

template <class T, class D>
template<class S>
void array_nd<T, D>::reshape(const array<size_t, S>& newsize, const T& s)
{
        // call array data class resize first
        base_class::resize(prod(newsize), s);

        ndim = newsize.length();
        sizes = newsize;
        strides = cumprod<size_t>(shift(sizes, 1, size_t(1)));
}


// resize

template <class T, class D>
void array_nd<T, D>::resize(size_t newsize)
// override the base data resize because it will be now invalid.
{
        // call array data class resize first
        array_nd_details::shrink_rearrange(*this, idx(newsize), idx(1));
        base_class::resize(newsize);
        array_nd_details::enlarge_rearrange(*this, idx(newsize), idx(1));

        ndim = 1;
        sizes.resize(1, newsize);
        strides.resize(1, 1);

}

template <class T, class D>
void array_nd<T, D>::resize(size_t newsize, const T& s)
// override the base data resize because it will be now invalid.
{
        // call array data class resize first
        array_nd_details::shrink_rearrange(*this, idx(newsize), idx(1), s);
        base_class::resize(newsize/*, s*/);
        array_nd_details::enlarge_rearrange(*this, idx(newsize), idx(1), s);

        ndim = 1;
        sizes.resize(1, newsize);
        strides.resize(1, 1);
}

template <class T, class D>
template<class S>
void array_nd<T, D>::resize(const array<size_t, S>& newsize)
{
        array<size_t, tiny> new_stride =
                cumprod<size_t>(shift(newsize, 1, size_t(1)));

        // call array data class resize first
        array_nd_details::shrink_rearrange(*this, newsize, new_stride);
        base_class::resize(prod(newsize));
        array_nd_details::enlarge_rearrange(*this, newsize, new_stride);

        ndim = newsize.length();
        sizes = newsize;
        strides = new_stride;
}

template <class T, class D>
template<class S>
void array_nd<T, D>::resize(const array<size_t, S>& newsize, const T& s)
{
        array<size_t, tiny> new_stride =
                cumprod<size_t>(shift(newsize, 1, size_t(1)));

        // call array data class resize first
        array_nd_details::shrink_rearrange(*this, newsize, new_stride, s);
        base_class::resize(prod(newsize) /*, s*/);
        array_nd_details::enlarge_rearrange(*this, newsize, new_stride, s);

        ndim = newsize.length();
        sizes = newsize;
        strides = new_stride;
}

// -------------------------------------------------------------
#if 0
//VC2005 Crashes with this! OMG......

template<class T, class D, class P>
inline
typename array_nd<T, D, P>::best_reference
        array_nd<T, D, P>::operator()(size_t s1)
{
        return (*this)[s1];
}

template<class T, class D, class P>
inline
typename array_nd<T, D, P>::best_reference
        array_nd<T, D, P>::operator()(size_t s1, size_t s2)
{
        return (*this)[s1 + s2 * strides[1]];
}

template<class T, class D, class P>
inline
typename array_nd<T, D, P>::best_reference
        array_nd<T, D, P>::operator()(size_t s1, size_t s2, size_t s3)
{
        return (*this)[s1 + s2 * strides[1] + s3 * strides[2]];
}

template<class T, class D, class P>
inline
typename array_nd<T, D, P>::best_reference
        array_nd<T, D, P>::operator()(size_t s1, size_t s2, size_t s3, size_t s4)
{
        return (*this)[s1 + s2 * strides[1] +
                                        s3 * strides[2] + s4 * strides[3]];
}

template<class T, class D, class P>
inline
typename array_nd<T, D, P>::best_reference
        array_nd<T, D, P>::operator()(size_t s1, size_t s2, size_t s3,
                                                        size_t s4, size_t s5)
{
        return (*this)[s1 + s2 * strides[1] + s3 * strides[2]
                                        + s4 * strides[3] + s5 * strides[4]];
}

template<class T, class D, class P>
inline
typename array_nd<T, D, P>::best_reference
        array_nd<T, D, P>::operator()(size_t s1, size_t s2, size_t s3, size_t s4,
                                                        size_t s5, size_t s6)
{
        return (*this)[s1 + s2 * strides[1] + s3 * strides[2] +
                        s4 * strides[3] + s5 * strides[4] + s6 * strides[5]];
}

template<class T, class D, class P>
inline
typename array_nd<T, D, P>::const_reference
        array_nd<T, D, P>::operator()(size_t s1) const
{
        return (*this)[s1];
}

template<class T, class D, class P>
inline
typename array_nd<T, D, P>::const_reference
        array_nd<T, D, P>::operator()(size_t s1, size_t s2) const
{
        return (*this)[s1 + s2 * strides[1]];
}

template<class T, class D, class P>
inline
typename array_nd<T, D, P>::const_reference
        array_nd<T, D, P>::operator()(size_t s1, size_t s2, size_t s3) const
{
        return (*this)[s1 + s2 * strides[1] + s3 * strides[2]];
}

template<class T, class D, class P>
inline
typename array_nd<T, D, P>::const_reference
        array_nd<T, D, P>::operator()(size_t s1, size_t s2, size_t s3,
                                                        size_t s4) const
{
        return (*this)[s1 + s2 * strides[1] + s3 * strides[2] +
                                                        s4 * strides[3]];
}
template<class T, class D, class P>
inline
typename array_nd<T, D, P>::const_reference
        array_nd<T, D, P>::operator()(size_t s1, size_t s2, size_t s3,
                                                size_t s4, size_t s5) const
{
        return (*this)[s1 + s2 * strides[1] + s3 * strides[2] +
                                        s4 * strides[3] + s5 * strides[4]];
}

template<class T, class D, class P>
inline
typename array_nd<T, D, P>::const_reference
        array_nd<T, D, P>::operator()(size_t s1, size_t s2, size_t s3,
                                        size_t s4, size_t s5, size_t s6) const
{
        return (*this)[s1 + s2 * strides[1] + s3 * strides[2] +
                        s4 * strides[3] + s5 * strides[4] + s6 * strides[5]];
}

#endif