ivl/details/array_nd/impl/gslice_array.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/>. */

#ifndef IVL_ARRAY_ND_DETAILS_GSLICE_ARRAY_HPP
#define IVL_ARRAY_ND_DETAILS_GSLICE_ARRAY_HPP

#if 0
namespace ivl {

//--------------------------------------------------------------
// CLASS gslice

class gslice
{
protected:
        template<class T, class S> friend class array;
        size_t start;           
        size_array sizes;       
        size_array strides;     

        template<class T, class S> friend class array_nd;

public:
        inline gslice() : start(0) { }

        inline gslice(size_t off, const size_array& length_array, const size_array& stride_array)
                : start(off), sizes(length_array), strides(stride_array) { }

        inline gslice(const array<slice>& as, size_array sz); // defined below

        inline size_t offset(size_array& index_array) const;
        // return total length of generalized slice
        inline size_t length() const;

};


//--------------------------------------------------------------
// TEMPLATE CLASS gslice_array

template<class T> class gslice_array : public gslice
{

private:
        template<class X,class Y> friend class array_nd;

        gslice_array(const gslice& gsl, T *ptr) : gslice(gsl), base_ptr(ptr) { }

        template <class S>
        gslice_array(const array<slice>& as, array_nd<T,S>& a) : gslice(as, a.sizes), base_ptr(a.base_ptr) { }

        T *base_ptr;

public:
        gslice_array(); // not defined
        gslice_array(const gslice_array&);      // not defined
        gslice_array& operator=(const gslice_array&);   // not defined

        void operator=(const array<T>& a) const;        
        void operator=(const T& s) const;                       

        void operator+=(const T& s) const;                      
        void operator-=(const T& s) const;                      
        void operator*=(const T& s) const;                      
        void operator/=(const T& s) const;                      
        void operator%=(const T& s) const;                      
        void operator^=(const T& s) const;                      
        void operator&=(const T& s) const;                      
        void operator|=(const T& s) const;                      
        void operator<<=(const T& s) const;                     
        void operator>>=(const T& s) const;                     

        void operator+=(const array_nd<T>& a) const;    
        void operator-=(const array_nd<T>& a) const;    
        void operator*=(const array_nd<T>& a) const;    
        void operator/=(const array_nd<T>& a) const;    
        void operator%=(const array_nd<T>& a) const;    
        void operator^=(const array_nd<T>& a) const;    
        void operator&=(const array_nd<T>& a) const;    
        void operator|=(const array_nd<T>& a) const;    
        void operator<<=(const array_nd<T>& a) const;   
        void operator>>=(const array_nd<T>& a) const;   
};


//--------------------------------------------------------------
// array_nd/glice_array MEMBER FUNCTIONS


template<class T, class D>
inline
typename array_nd<T, D>::NewDerived array_nd<T, D>::operator()(const gslice& gsl) const
{
        return array_nd<T, D>::NewDerived(gslice_array<T>(gsl, this->c_ptr()));
}

template<class T, class D>
inline
gslice_array<T> array_nd<T, D>::operator()(const gslice& gsl)
{
        return gslice_array<T>(gsl, this->c_ptr());
}

template<class T, class D>
inline
typename array_nd<T, D>::Derived& array_nd<T, D>::operator=(const gslice_array<T>& ga)
{
        this->tidy(true);
        grow(ga.length());
        ndim = ga.strides.size();
        sizes = ga.sizes;
        strides = cumprod(shift(sizes, 1, size_t(1)));
        size_array index_array(ga.sizes.size(), (size_t)0); // to index_array einai to voh8htiko array (000,001,010,011 klp.)

        for (size_t i = 0; i < this->length(); ++i)
                (*this)[i] = ga.base_ptr[ga.offset(index_array)];

        return derived();
}


//--------------------------------------------------------------
// array_nd/array<slice> MEMBER FUNCTIONS

template<class T, class D>
inline
typename array_nd<T, D>::NewDerived array_nd<T, D>::operator()(const array<slice>& a) const
{
        return typename array_nd<T, D>::NewDerived(gslice_array<T>(a,
                *const_cast<array_nd<T, D>* >(this)));
}

template<class T, class D>
inline
gslice_array<T> array_nd<T, D>::operator()(const array<slice>& a)
{
        return gslice_array<T>(a, *this);
}


// --------------------------------------------------------------
// GSLICE MEMBER FUNCTIONS

gslice::gslice(const array<slice>& as, size_array sz)
{
        size_t a_len = as.length();

        size_array offsets(a_len);
        sizes   = size_array(a_len);
        strides = size_array(a_len);

        for (size_t i = 0; i < a_len; i++) {
                offsets[i] = as[i].start;
                sizes[i]   = as[i].length;
                strides[i] = as[i].stride;
        }

        size_array strd(cumprod(shift(sz,1, size_t(1))));

        size_array tmp = offsets * strd;

        start = sum(tmp);
}

size_t gslice::offset(size_array& index_array) const
{
        size_t i, offs = start;

        for (i = 0; i < index_array.size(); ++i)
                offs += index_array[i] * strides[i];    // compute offset

        i = 0;
        while (i < index_array.size())
                if (++index_array[i] < sizes[i]) break; // increment done, quit
                else index_array[i++] = 0;      // carry to more-significant index
        return (offs);
}

size_t gslice::length() const
{
        if (sizes.size() == 0)
                return 0;

        return prod(sizes);
}

// --------------------------------------------------------------
// GSLICE_ARRAY MEMBER FUNCTIONS & OPERATORS

template <class T>
void gslice_array<T>::operator=(const array<T>& a) const
{
        size_array index_array(sizes.size(), (size_t)0);

        for (size_t i = 0; i < (size_t) length(); ++i )
                base_ptr[offset(index_array)] = a[i];
}

template <class T>
void gslice_array<T>::operator=(const T& s) const
{
        size_array index_array(sizes.size(), (size_t)0);

        for (size_t i = 0; i < (size_t) length(); ++i )
                base_ptr[offset(index_array)] = s;
}

template <class T>
void gslice_array<T>::operator+=(const T& s) const
{
        size_array index_array(sizes.size(), (size_t)0);

        for (size_t i = 0; i < (size_t) length(); ++i )
                base_ptr[offset(index_array)] += s;
}

template <class T>
void gslice_array<T>::operator-=(const T& s) const
{
        size_array index_array(sizes.size(), (size_t)0);

        for (size_t i = 0; i < (size_t) length(); ++i )
                base_ptr[offset(index_array)] -= s;
}

template <class T>
void gslice_array<T>::operator*=(const T& s) const
{
        size_array index_array(sizes.size(), (size_t)0);
        for (size_t i = 0; i < (size_t) length(); ++i )
                base_ptr[offset(index_array)] *= s;
}

template <class T>
void gslice_array<T>::operator/=(const T& s) const
{
        size_array index_array(sizes.size(), (size_t)0);

        for (size_t i = 0; i < (size_t) length(); ++i )
                base_ptr[offset(index_array)] /= s;
}

template <class T>
void gslice_array<T>::operator%=(const T& s) const
{
        size_array index_array(sizes.size(), (size_t)0);

        for (size_t i = 0; i < (size_t) length(); ++i )
                base_ptr[offset(index_array)] %= s;
}

template <class T>
void gslice_array<T>::operator^=(const T& s) const
{
        size_array index_array(sizes.size(), (size_t)0);

        for (size_t i = 0; i < (size_t) length(); ++i )
                base_ptr[offset(index_array)] ^= s;
}

template <class T>
void gslice_array<T>::operator&=(const T& s) const
{
        size_array index_array(sizes.size(), (size_t)0);

        for (size_t i = 0; i < (size_t) length(); ++i )
                base_ptr[offset(index_array)] &= s;
}

template <class T>
void gslice_array<T>::operator|=(const T& s) const
{
        size_array index_array(sizes.size(), (size_t)0);

        for (size_t i = 0; i < (size_t) length(); ++i )
                base_ptr[offset(index_array)] |= s;
}

template <class T>
void gslice_array<T>::operator<<=(const T& s) const
{
        size_array index_array(sizes.size(), (size_t)0);
        for (size_t i = 0; i < (size_t) length(); ++i )
                base_ptr[offset(index_array)] <<= s;
}

template <class T>
void gslice_array<T>::operator>>=(const T& s) const
{
        size_array index_array(sizes.size(), (size_t)0);
        for (size_t i = 0; i < (size_t) length(); ++i )
                base_ptr[offset(index_array)] >>= s;
}

template <class T>
void gslice_array<T>::operator*=(const array_nd<T>& a) const
{
        size_array index_array(sizes.size(), (size_t)0);

        for (size_t i = 0; i < (size_t) length(); ++i )
                base_ptr[offset(index_array)] *= a[i];
}

template <class T>
void gslice_array<T>::operator/=(const array_nd<T>& a) const
{
        size_array index_array(sizes.size(), (size_t)0);

        for (size_t i = 0; i < (size_t) length(); ++i )
                base_ptr[offset(index_array)] /= a[i];
}

template <class T>
void gslice_array<T>::operator%=(const array_nd<T>& a) const
{
        size_array index_array(sizes.size(), (size_t)0);

        for (size_t i = 0; i < (size_t) length(); ++i )
                base_ptr[offset(index_array)] %= a[i];
}

template <class T>
void gslice_array<T>::operator+=(const array_nd<T>& a) const
{
        size_array index_array(sizes.size(), (size_t)0);

        for (size_t i = 0; i < (size_t) length(); ++i )
                base_ptr[offset(index_array)] += a[i];
}

template <class T>
void gslice_array<T>::operator-=(const array_nd<T>& a) const
{
        size_array index_array(sizes.size(), (size_t)0);

        for (size_t i = 0; i < (size_t) length(); ++i )
                base_ptr[offset(index_array)] -= a[i];
}

template <class T>
void gslice_array<T>::operator^=(const array_nd<T>& a) const
{
        size_array index_array(sizes.size(), (size_t)0);

        for (size_t i = 0; i < (size_t) length(); ++i )
                base_ptr[offset(index_array)] ^= a[i];
}

template <class T>
void gslice_array<T>::operator&=(const array_nd<T>& a) const
{
        size_array index_array(sizes.size(), (size_t)0);

        for (size_t i = 0; i < (size_t) length(); ++i )
                base_ptr[offset(index_array)] &= a[i];
}

template <class T>
void gslice_array<T>::operator|=(const array_nd<T>& a) const
{
        size_array index_array(sizes.size(), (size_t)0);

        for (size_t i = 0; i < (size_t) length(); ++i )
                base_ptr[offset(index_array)] |= a[i];
}

template <class T>
void gslice_array<T>::operator<<=(const array_nd<T>& a) const
{
        size_array index_array(sizes.size(), (size_t)0);

        for (size_t i = 0; i < (size_t) length(); ++i )
                base_ptr[offset(index_array)] <<= a[i];
}

template <class T>
void gslice_array<T>::operator>>=(const array_nd<T>& a) const
{
        size_array index_array(sizes.size(), (size_t)0);

        for (size_t i = 0; i < (size_t) length(); ++i )
                base_ptr[offset(index_array)] >>= a[i];
}

} // namespace ivl
#endif

#endif // IVL_ARRAY_ND_DETAILS_GSLICE_ARRAY_HPP