tvalarray.h

#ifndef _tvalarray_h
#define _tvalarray_h

#if defined(DEBUG) || defined(ARRAY_BOUNDS_CHECK)
#include <iostream>
#include <cstdlib> /* abort() */
#ifndef _COREDEBUG_STR
#define _COREDEBUG_STR "To debug the core, use this command:\n"\
"    gdb -c core /path/to/executable             (gdb) bt"
#endif
#endif


#if defined(DEBUG) || defined(ARRAY_BOUNDS_CHECK)
inline bool resize_warning()
{
    std::cerr<<"General information: do not use tvalarray< tvalarray<T> >::resize(unsigned, tvalarray<T>),\n"
             <<"because does not work!\n"
             <<"In case of hyper-arrays use resize(tvalarray< tvalarray<T> >&, unsigned, tvalarray<T>) instead!\n";
    return true;
}

inline bool display_resize_warning()
{
    static const bool resize_warning_buffer=resize_warning();
    return resize_warning_buffer;
}
#endif


template <class T>
class tvalarray
{
private:
    T* x;
    unsigned n;
    const bool ownsData;

protected:
    tvalarray(T* array, unsigned _n, bool realloc);

public:
    tvalarray() : ownsData(true) {
        x = 0;
        n = 0;
    }

    tvalarray(unsigned _n) : ownsData(true) {
        if(_n > 0) {
            n=_n;
            x = new T[n];
            *this = T(); // initialize elements
        } else {
            n = 0;
            x = 0;
        }
    }

    tvalarray(const T& value, unsigned _n);

    tvalarray(const T* values, unsigned _n);

    tvalarray(const tvalarray& a) : ownsData(true) {
        n = a.n;
        if(n > 0) {
            x = new T[n];
            const T* y = a.x;
            for(unsigned i = 0; i < n; ++i) {
                x[i] = y[i];
            }
        } else {
            n = 0;
            x = 0;
        }
    }

    ~tvalarray() {
        if(x != 0 && ownsData) {
            delete[] x;
        }
    }

    unsigned size() const {
        return n;
    }

    operator T*() {
        return x;
    }

    operator const T*() const {
        return x;
    }

    tvalarray& operator =(const tvalarray& a) {
#if defined(DEBUG) || defined(ARRAY_BOUNDS_CHECK)
        if(n != a.n) {
            std::cerr << "Fatal error: tvalarray a = b with different sizes ("
                 << n << " != " << a.n << ")\n" _COREDEBUG_STR << std::endl;
            ::abort();
        }
#endif
        const T* y = a.x;
        for(unsigned i = 0; i < n; ++i) {
            x[i] = y[i];
        }
        return *this;
    }

    template <class Tp>
    friend void copy(const tvalarray<Tp>& source, tvalarray<Tp>& dest);

    template <class Tp>
    friend void copy(const tvalarray< tvalarray<Tp> >& source, tvalarray< tvalarray<Tp> >& dest);

    tvalarray& operator +=(const tvalarray& a) {
#if defined(DEBUG) || defined(ARRAY_BOUNDS_CHECK)
        if(n != a.n) {
            std::cerr << "Fatal error: tvalarray a += b with different sizes ("
                 << n << " != " << a.n << ")\n" _COREDEBUG_STR << std::endl;
            ::abort();
        }
#endif
        const T* y = a.x;
        for(unsigned i = 0; i < n; ++i) {
            x[i] += y[i];
        }
        return *this;
    }

    tvalarray& operator +=(const T& c) {
        for(unsigned i = 0; i < n; ++i) {
            x[i] += c;
        }
        return *this;
    }

    tvalarray& operator ^=(const tvalarray& a) {
#if defined(DEBUG) || defined(ARRAY_BOUNDS_CHECK)
        if(n != a.n) {
            std::cerr << "Fatal error: tvalarray a ^= b with different sizes ("
                 << n << " != " << a.n << ")\n" _COREDEBUG_STR << std::endl;
            ::abort();
        }
#endif
        const T* y = a.x;
        for(unsigned i = 0; i < n; ++i) {
            x[i] ^= y[i];
        }
        return *this;
    }

    tvalarray& operator ^=(const T& c) {
        for(unsigned i = 0; i < n; ++i) {
            x[i] ^= c;
        }
        return *this;
    }

    tvalarray& operator &=(const tvalarray& a) {
#if defined(DEBUG) || defined(ARRAY_BOUNDS_CHECK)
        if(n != a.n) {
            std::cerr << "Fatal error: tvalarray a &= b with different sizes ("
                 << n << " != " << a.n << ")\n" _COREDEBUG_STR << std::endl;
            ::abort();
        }
#endif
        const T* y = a.x;
        for(unsigned i = 0; i < n; ++i) {
            x[i] &= y[i];
        }
        return *this;
    }

    tvalarray& operator &=(const T& c) {
        for(unsigned i = 0; i < n; ++i) {
            x[i] &= c;
        }
        return *this;
    }

    tvalarray& operator |=(const tvalarray& a) {
#if defined(DEBUG) || defined(ARRAY_BOUNDS_CHECK)
        if(n != a.n) {
            std::cerr << "Fatal error: tvalarray a |= b with different sizes ("
                 << n << " != " << a.n << ")\n" _COREDEBUG_STR << std::endl;
            ::abort();
        }
#endif
        const T* y = a.x;
        for(unsigned i = 0; i < n; ++i) {
            x[i] |= y[i];
        }
        return *this;
    }

    tvalarray& operator |=(const T& c) {
        for(unsigned i = 0; i < n; ++i) {
            x[i] |= c;
        }
        return *this;
    }

    tvalarray& operator <<=(const tvalarray& a) {
#if defined(DEBUG) || defined(ARRAY_BOUNDS_CHECK)
        if(n != a.n) {
            std::cerr << "Fatal error: tvalarray a <<= b with different sizes ("
                 << n << " != " << a.n << ")\n" _COREDEBUG_STR << std::endl;
            ::abort();
        }
#endif
        const T* y = a.x;
        for(unsigned i = 0; i < n; ++i) {
            x[i] <<= y[i];
        }
        return *this;
    }

    tvalarray& operator <<=(const T& c) {
        for(unsigned i = 0; i < n; ++i) {
            x[i] <<= c;
        }
        return *this;
    }

    tvalarray& operator >>=(const tvalarray& a) {
#if defined(DEBUG) || defined(ARRAY_BOUNDS_CHECK)
        if(n != a.n) {
            std::cerr << "Fatal error: tvalarray a >>= b with different sizes ("
                 << n << " != " << a.n << ")\n" _COREDEBUG_STR << std::endl;
            ::abort();
        }
#endif
        const T* y = a.x;
        for(unsigned i = 0; i < n; ++i) {
            x[i] >>= y[i];
        }
        return *this;
    }

    tvalarray& operator >>=(const T& c) {
        for(unsigned i = 0; i < n; ++i) {
            x[i] >>= c;
        }
        return *this;
    }

    tvalarray& operator *=(const tvalarray& a) {
#if defined(DEBUG) || defined(ARRAY_BOUNDS_CHECK)
        if(n != a.n) {
            std::cerr << "Fatal error: tvalarray a *= b with different sizes ("
                 << n << " != " << a.n << ")\n" _COREDEBUG_STR << std::endl;
            ::abort();
        }
#endif
        const T* y = a.x;
        for(unsigned i = 0; i < n; ++i) {
            x[i] *= y[i];
        }
        return *this;
    }

    tvalarray& operator *=(const T& c) {
        for(unsigned i = 0; i < n; ++i) {
            x[i] *= c;
        }
        return *this;
    }

    tvalarray& operator /=(const tvalarray& a) {
#if defined(DEBUG) || defined(ARRAY_BOUNDS_CHECK)
        if(n != a.n) {
            std::cerr << "Fatal error: tvalarray a /= b with different sizes ("
                 << n << " != " << a.n << ")\n" _COREDEBUG_STR << std::endl;
            ::abort();
        }
#endif
        const T* y = a.x;
        for(unsigned i = 0; i < n; ++i) {
            x[i] /= y[i];
        }
        return *this;
    }

    tvalarray& operator /=(const T& c) {
        for(unsigned i = 0; i < n; ++i) {
            x[i] /= c;
        }
        return *this;
    }

    tvalarray& operator %=(const tvalarray& a) {
#if defined(DEBUG) || defined(ARRAY_BOUNDS_CHECK)
        if(n != a.n) {
            std::cerr << "Fatal error: tvalarray a %= b with different sizes ("
                 << n << " != " << a.n << ")\n" _COREDEBUG_STR << std::endl;
            ::abort();
        }
#endif
        const T* y = a.x;
        for(unsigned i = 0; i < n; ++i) {
            x[i] %= y[i];
        }
        return *this;
    }

    tvalarray& operator %=(const T& c) {
        for(unsigned i = 0; i < n; ++i) {
            x[i] %= c;
        }
        return *this;
    }

    tvalarray& operator =(const T& c) {
        for(unsigned i = 0; i < n; ++i) {
            x[i] = c;
        }
        return *this;
    }

    tvalarray& operator -=(const T& c) {
        for(unsigned i = 0; i < n; ++i) {
            x[i] -= c;
        }
        return *this;
    }

    tvalarray& operator -=(const tvalarray& a) {
#if defined(DEBUG) || defined(ARRAY_BOUNDS_CHECK)
        if(n != a.n) {
            std::cerr << "Fatal error: tvalarray a -= b with different sizes ("
                 << n << " != " << a.n << ")\n" _COREDEBUG_STR << std::endl;
            ::abort();
        }
#endif
        const T* y = a.x;
        for(unsigned i = 0; i < n; ++i) {
            x[i] -= y[i];
        }
        return *this;
    }

    void resize(unsigned _n, T value = T()) {
#if defined(DEBUG) || defined(ARRAY_BOUNDS_CHECK)
        display_resize_warning();
#endif
        if(_n > n) {
            realloc(_n);
        }
        if((n = _n) > 0) {
            *this = value; // initialize elements (does not work for T==tvalarray<>)
        }
    }

    template <class Tp>
    friend void resize(tvalarray<Tp>& arr, unsigned _n, Tp value = Tp());

    template <class Tp>
    friend void resize(tvalarray< tvalarray<Tp> >& arr, unsigned _n, tvalarray<Tp> value = tvalarray<Tp>());

    T operator [](int k) const {
#if defined(DEBUG) || defined(ARRAY_BOUNDS_CHECK)
        if(k < 0 || k >= (int)n) {
            std::cerr << "Fatal error: tvalarray index " << k
                 << " out of range [0, " << n << "[\n" _COREDEBUG_STR << std::endl;
            ::abort();
        }
#endif
        return x[k];
    }

    T& operator [](int k) {
#if defined(DEBUG) || defined(ARRAY_BOUNDS_CHECK)
        if(k < 0 || k >= (int)n) {
            std::cerr << "Fatal error: tvalarray index " << k
                 << " out of range [0, " << n << "[\n" _COREDEBUG_STR << std::endl;
            ::abort();
        }
#endif
        return x[k];
    }

    tvalarray shift(int k) const;

    tvalarray cshift(int k) const;

public:
    void realloc(int _n) {
        if(ownsData) {
            if ( x!=0 ) delete [] x;
            if(_n > 0) { n = _n; x = new T[n]; }
            else { n=0; x=0; }
        } else {
#if defined(DEBUG) || defined(ARRAY_BOUNDS_CHECK)
            std::cerr << "Fatal error: reallocating tvalarray not owning data\n" 
                         << _COREDEBUG_STR << std::endl;
            ::abort();
#endif
            x = 0;
            n = 0;
        }
    }
};

template <class T>
class tvalarray_wrapper: public tvalarray<T>
{
public:
    tvalarray_wrapper(T* array, unsigned n): tvalarray<T>(array, n, false) {
    }
};

template <class T> tvalarray<T> tvalarray<T>::shift(int k) const
{
    tvalarray<T> result(n);
    T* q = result.x;
    if((k > 0 && (unsigned)k >= n) || (k < 0 && (unsigned)(-k) >= n)) {
        T* end = result.x + n;
        while(q != end) {
            *(q++) = 0;
        }
    } else if(k >= 0) {
        T* q = result.x;
        T* end = x + n;
        for(T* p = x + k; p != end; ++p) {
            *(q++) = *p;
        }
        for(int i = 0; i < k; ++i) {
            *(q++) = 0;
        }
    } else {
        k = -k;
        for(int i = 0; i < k; ++i) {
            *(q++) = 0;
        }
        T* end = x + n - k;
        for(T* p = x; p != end; ++p) {
            *(q++) = *p;
        }
    }
    return result;
}

template <class T> tvalarray<T> tvalarray<T>::cshift(int k) const
{
    if(k < 0) {
        k = n - (-k) % n;
    } else if((unsigned)k >= n) {
        k = k % n;
    }
    tvalarray<T> result(n);
    T* end = x + n;
    T* q = result.x;
    for(T* p = x + k; p != end; ++p) {
        *(q++) = *p;
    }
    end = x + k;
    for(T* p = x; p != end; ++p) {
        *(q++) = *p;
    }
    return result;
}

template <class T> tvalarray<T>::tvalarray(const T& value, unsigned _n)
 : ownsData(true)
{
    if(_n > 0) {
        n = _n;
        x = new T[n];
        *this = value; // initialize elements
    } else {
        n=0;
        x = 0;
    }
}

template <class T> tvalarray<T>::tvalarray(T* array, unsigned _n, bool realloc)
 : ownsData(realloc)
{
    if(_n > 0) {
        n=_n;
        if(realloc) {
            x = new T[n];
            for(unsigned i = 0; i < n; ++i) {
                x[i] = array[i]; // initialize elements
            }
        } else {
            x = array;
        }
    } else {
        n=0;
        x = 0;
    }
}

template <class T> tvalarray<T>::tvalarray(const T* values, unsigned _n)
 : ownsData(true)
{
    if(_n > 0) {
        n=_n;
        x = new T[n];
        for(unsigned i = 0; i < n; ++i) {
            x[i] = values[i]; // initialize elements
        }
    } else {
        n=0;
        x = 0;
    }
}

template <class T>
void copy(const tvalarray<T>& source, tvalarray<T>& dest)
{
    if ( dest.n!=source.n )
    {
        dest.realloc(source.n);
    }
    const T* y = source.x;
    for(unsigned i = 0; i < dest.n; ++i)
    {
        dest.x[i] = y[i]; // <- Here T==tvalarray<something> would not work.
    }
}

template <class T>
void copy(const tvalarray< tvalarray<T> >& source, tvalarray< tvalarray<T> >& dest)
{
    if ( dest.n!=source.n )
    {
        dest.realloc(source.n);
    }
    const tvalarray<T>* y = source.x;
    for(unsigned i = 0; i < dest.n; ++i) {
        copy(y[i], dest.x[i]); // <- Here T==tvalarray<something> would not work.
    }
}

template <class T>
void resize(tvalarray< T >& arr, unsigned _n, T value=T())
{
    if(_n > arr.n) {
        arr.realloc(_n);
    }
    if(arr.n > 0) {
        arr=value;
    }
}

template <class T>
void resize(tvalarray< tvalarray<T> >& arr, unsigned _n, tvalarray<T> value=tvalarray<T>())
{
    if(_n > arr.n) {
        arr.realloc(_n);
    }
    if(arr.n > 0) {
        for ( unsigned int i=0 ; i<arr.n ; ++i ) copy(value, arr[i]);
    }
}

#ifdef DEBUG
template <class T>
inline std::ostream& operator <<(std::ostream& out, const tvalarray<T>& x)
{
    for(unsigned i = 0; i < x.size(); ++i) {
        out << x[i];
        if(i+1 < x.size()) {
            out << ", ";
        }
    }
    return out;
}
#endif /* DEBUG */

#endif /* _tvalarray_h */