array.h

Go to the documentation of this file.

/* This file is part of the Palabos library.
 *
 * Copyright (C) 2011 FlowKit Sarl
 * Avenue de Chailly 23
 * 1012 Lausanne, Switzerland
 * E-mail contact: contact@flowkit.com
 *
 * The most recent release of Palabos can be downloaded at 
 * <http://www.palabos.org/>
 *
 * The library Palabos is free software: you can redistribute it and/or
 * modify it under the terms of the GNU Affero General Public License as
 * published by the Free Software Foundation, either version 3 of the
 * License, or (at your option) any later version.
 *
 * The library 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 Affero General Public License for more details.
 * 
 * You should have received a copy of the GNU Affero General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
*/

#ifndef ARRAY_H
#define ARRAY_H

#include "core/globalDefs.h"
#include "core/plbDebug.h"
#include <algorithm>

namespace plb {

template<typename T, pluint size>
class Array {
public:
    Array() { }
    template<typename U>
    Array(Array<U,size> const& rhs) {
        std::copy(&rhs[0], &rhs[0]+size, data);
    }
    template<typename U>
    Array<T,size>& operator=(Array<U,size> const& rhs) {
        std::copy(&rhs[0], &rhs[0]+size, data);
    }
    T& operator[](pluint index) {
        PLB_PRECONDITION(index<size);
        return data[index];
    }
    T const& operator[](pluint index) const {
        PLB_PRECONDITION(index<size);
        return data[index];
    }
    void from_cArray(T const* cArray) {
        std::copy(cArray, cArray+size, data);
    }
    void to_cArray(T* cArray) const {
        std::copy(data, data+size, cArray);
    }
    void resetToZero() {
        std::fill_n(data, size, T());
    }
    Array<T,size>& operator += (Array<T,size> const& b) {
        for (pluint i=0; i<size; ++i) {
            data[i] += b[i];
        }
        return *this;
    }
    Array<T,size>& operator += (T alpha) {
        for (pluint i=0; i<size; ++i) {
            data[i] += alpha;
        }
        return *this;
    }
    Array<T,size>& operator -= (Array<T,size> const& b) {
        for (pluint i=0; i<size; ++i) {
            data[i] -= b[i];
        }
        return *this;
    }
    Array<T,size>& operator -= (T alpha) {
        for (pluint i=0; i<size; ++i) {
            data[i] -= alpha;
        }
        return *this;
    }
    Array<T,size>& operator *= (Array<T,size> const& b) {
        for (pluint i=0; i<size; ++i) {
            data[i] *= b[i];
        }
        return *this;
    }
    Array<T,size>& operator *= (T alpha) {
        for (pluint i=0; i<size; ++i) {
            data[i] *= alpha;
        }
        return *this;
    }
    Array<T,size>& operator /= (Array<T,size> const& b) {
        for (pluint i=0; i<size; ++i) {
            data[i] /= b[i];
        }
        return *this;
    }
    Array<T,size>& operator /= (T alpha) {
        for (pluint i=0; i<size; ++i) {
            data[i] /= alpha;
        }
        return *this;
    }
private:
    T data[size];
};

template <typename T, pluint size>
Array<T,size> operator+(Array<T,size> const& a, Array<T,size> const& b) {
    Array<T,size> result;
    for (pluint i=0; i<size; ++i) {
        result[i] = a[i] + b[i];
    }
    return result;
}

template<typename T, pluint size>
Array<T,size> operator+(Array<T,size> const& a, T alpha) {
    Array<T,size> result;
    for (pluint i=0; i<size; ++i) {
        result[i] = a[i] + alpha;
    }
    return result;
}

template<typename T, pluint size>
Array<T,size> operator+(T alpha, Array<T,size> const& a) {
    Array<T,size> result;
    for (pluint i=0; i<size; ++i) {
        result[i] = alpha + a[i];
    }
    return result;
}

template<typename T, pluint size>
Array<T,size> operator-(Array<T,size> const& a, Array<T,size> const& b) {
    Array<T,size> result;
    for (pluint i=0; i<size; ++i) {
        result[i] = a[i] - b[i];
    }
    return result;
}

template<typename T, pluint size>
Array<T,size> operator-(Array<T,size> const& a) {
    Array<T,size> result;
    for (pluint i=0; i<size; ++i) {
        result[i] = -a[i];
    }
    return result;
}

template<typename T, pluint size>
Array<T,size> operator-(Array<T,size> const& a, T alpha) {
    Array<T,size> result;
    for (pluint i=0; i<size; ++i) {
        result[i] = a[i] - alpha;
    }
    return result;
}

template<typename T, pluint size>
Array<T,size> operator-(T alpha, Array<T,size> const& a) {
    Array<T,size> result;
    for (pluint i=0; i<size; ++i) {
        result[i] = alpha - a[i];
    }
    return result;
}

template<typename T, pluint size>
Array<T,size> operator*(Array<T,size> const& a, Array<T,size> const& b) {
    Array<T,size> result;
    for (pluint i=0; i<size; ++i) {
        result[i] = a[i] * b[i];
    }
    return result;
}

template<typename T, pluint size>
Array<T,size> operator*(Array<T,size> const& a, T alpha) {
    Array<T,size> result;
    for (pluint i=0; i<size; ++i) {
        result[i] = a[i] * alpha;
    }
    return result;
}

template<typename T, pluint size>
Array<T,size> operator*(T alpha, Array<T,size> const& a) {
    Array<T,size> result;
    for (pluint i=0; i<size; ++i) {
        result[i] = alpha * a[i];
    }
    return result;
}

template<typename T, pluint size>
Array<T,size> operator/(Array<T,size> const& a, Array<T,size> const& b) {
    Array<T,size> result;
    for (pluint i=0; i<size; ++i) {
        result[i] = a[i] / b[i];
    }
    return result;
}

template<typename T, pluint size>
Array<T,size> operator/(Array<T,size> const& a, T alpha) {
    Array<T,size> result;
    for (pluint i=0; i<size; ++i) {
        result[i] = a[i] / alpha;
    }
    return result;
}

template<typename T, pluint size>
inline bool operator==(Array<T,size> const& A, Array<T,size> const& B) {
    for (pluint iA = 0; iA < size; ++iA) {
        if (A[iA] != B[iA]) return false;
    }
    return true;
}

template<typename T, pluint size>
inline bool operator!=(Array<T,size> const& A, Array<T,size> const& B) {
    for (pluint iA = 0; iA < size; ++iA) {
        if (A[iA] != B[iA]) return true;
    }
    return false;
}

template<typename T, pluint size>
inline bool operator<(Array<T,size> const& A, Array<T,size> const& B) {
    for (pluint iA=0; iA<size; ++iA) {
        if (A[iA] < B[iA]) return true;
        if (A[iA] > B[iA]) return false;
    }
    return false;
}

template<typename T, pluint size>
Array<T,size> operator/(T alpha, Array<T,size> const& a) {
    Array<T,size> result;
    for (pluint i=0; i<size; ++i) {
        result[i] = alpha / a[i];
    }
    return result;
}


template<typename T>
class Array<T,2> {
public:
    Array() { }
    Array(T x, T y) {
        data[0] = x;
        data[1] = y;
    }
    template<typename U>
    Array(Array<U,2> const& rhs) {
        data[0] = (T) rhs[0];
        data[1] = (T) rhs[1];
    }
    template<typename U>
    Array<T,2>& operator=(Array<U,2> const& rhs) {
        data[0] = (T) rhs[0];
        data[1] = (T) rhs[1];
    }
    T& operator[](pluint index) {
        PLB_PRECONDITION(index<2);
        return data[index];
    }
    T const& operator[](pluint index) const {
        PLB_PRECONDITION(index<2);
        return data[index];
    }
    void from_cArray(T const* cArray) {
        data[0] = cArray[0];
        data[1] = cArray[1];
    }
    void to_cArray(T* cArray) const {
        cArray[0] = data[0];
        cArray[1] = data[1];
    }
    void resetToZero() {
        data[0] = T();
        data[1] = T();
    }
    Array<T,2>& operator+=(Array<T,2> const& b) {
        data[0] += b[0];
        data[1] += b[1];
        return *this;
    }
    Array<T,2>& operator+=(T alpha) {
        data[0] += alpha;
        data[1] += alpha;
        return *this;
    }
    Array<T,2>& operator-=(Array<T,2> const& b) {
        data[0] -= b[0];
        data[1] -= b[1];
        return *this;
    }
    Array<T,2>& operator-=(T alpha) {
        data[0] -= alpha;
        data[1] -= alpha;
        return *this;
    }
    Array<T,2>& operator*=(Array<T,2> const& b) {
        data[0] *= b[0];
        data[1] *= b[1];
        return *this;
    }
    Array<T,2>& operator*=(T alpha) {
        data[0] *= alpha;
        data[1] *= alpha;
        return *this;
    }
    Array<T,2>& operator/=(Array<T,2> const& b) {
        data[0] /= b[0];
        data[1] /= b[1];
        return *this;
    }
    Array<T,2>& operator/=(T alpha) {
        data[0] /= alpha;
        data[1] /= alpha;
        return *this;
    }
private:
    T data[2];
};

template<typename T>
Array<T,2> operator+(Array<T,2> const& a, Array<T,2> const& b) {
    return Array<T,2>(a[0]+b[0], a[1]+b[1]);
}

template<typename T>
Array<T,2> operator+(Array<T,2> const& a, T alpha) {
    return Array<T,2>(a[0]+alpha, a[1]+alpha);
}

template<typename T>
Array<T,2> operator+(T alpha, Array<T,2> const& a) {
    return Array<T,2>(alpha+a[0], alpha+a[1]);
}

template<typename T>
Array<T,2> operator-(Array<T,2> const& a, Array<T,2> const& b) {
    return Array<T,2>(a[0]-b[0], a[1]-b[1]);
}

template<typename T>
Array<T,2> operator-(Array<T,2> const& a) {
    return Array<T,2>(-a[0],-a[1]);
}

template<typename T>
Array<T,2> operator-(Array<T,2> const& a, T alpha) {
    return Array<T,2>(a[0]-alpha, a[1]-alpha);
}

template<typename T>
Array<T,2> operator-(T alpha, Array<T,2> const& a) {
    return Array<T,2>(alpha-a[0], alpha-a[1]);
}

template<typename T>
Array<T,2> operator*(Array<T,2> const& a, Array<T,2> const& b) {
    return Array<T,2>(a[0]*b[0], a[1]*b[1]);
}

template<typename T>
Array<T,2> operator*(Array<T,2> const& a, T alpha) {
    return Array<T,2>(a[0]*alpha, a[1]*alpha);
}

template<typename T>
Array<T,2> operator*(T alpha, Array<T,2> const& a) {
    return Array<T,2>(alpha*a[0], alpha*a[1]);
}

template<typename T>
Array<T,2> operator/(Array<T,2> const& a, Array<T,2> const& b) {
    return Array<T,2>(a[0]/b[0], a[1]/b[1]);
}

template<typename T>
Array<T,2> operator/(Array<T,2> const& a, T alpha) {
    return Array<T,2>(a[0]/alpha, a[1]/alpha);
}

template<typename T>
Array<T,2> operator/(T alpha, Array<T,2> const& a) {
    return Array<T,2>(alpha/a[0], alpha/a[1]);
}

template<typename T>
class Array<T,3> {
public:
    Array() { }
    Array(T x, T y, T z) {
        data[0] = x;
        data[1] = y;
        data[2] = z;
    }
    template<typename U>
    Array(Array<U,3> const& rhs) {
        data[0] = (T) rhs[0];
        data[1] = (T) rhs[1];
        data[2] = (T) rhs[2];
    }
    template<typename U>
    Array<T,3>& operator=(Array<U,3> const& rhs) {
        data[0] = (T) rhs[0];
        data[1] = (T) rhs[1];
        data[2] = (T) rhs[2];
    }
    T& operator[](pluint index) {
        PLB_PRECONDITION(index<3);
        return data[index];
    }
    T const& operator[](pluint index) const {
        PLB_PRECONDITION(index<3);
        return data[index];
    }
    void from_cArray(T const* cArray) {
        data[0] = cArray[0];
        data[1] = cArray[1];
        data[2] = cArray[2];
    }
    void to_cArray(T* cArray) const {
        cArray[0] = data[0];
        cArray[1] = data[1];
        cArray[2] = data[2];
    }
    void resetToZero() {
        data[0] = T();
        data[1] = T();
        data[2] = T();
    }
    Array<T,3>& operator += (Array<T,3> const& b) {
        data[0] += b[0];
        data[1] += b[1];
        data[2] += b[2];
        return *this;
    }
    Array<T,3>& operator += (T alpha) {
        data[0] += alpha;
        data[1] += alpha;
        data[2] += alpha;
        return *this;
    }
    Array<T,3>& operator -= (Array<T,3> const& b) {
        data[0] -= b[0];
        data[1] -= b[1];
        data[2] -= b[2];
        return *this;
    }
    Array<T,3>& operator -= (T alpha) {
        data[0] -= alpha;
        data[1] -= alpha;
        data[2] -= alpha;
        return *this;
    }
    Array<T,3>& operator *= (Array<T,3> const& b) {
        data[0] *= b[0];
        data[1] *= b[1];
        data[2] *= b[2];
        return *this;
    }
    Array<T,3>& operator *= (T alpha) {
        data[0] *= alpha;
        data[1] *= alpha;
        data[2] *= alpha;
        return *this;
    }
    Array<T,3>& operator /= (Array<T,3> const& b) {
        data[0] /= b[0];
        data[1] /= b[1];
        data[2] /= b[2];
        return *this;
    }
    Array<T,3>& operator /= (T alpha) {
        data[0] /= alpha;
        data[1] /= alpha;
        data[2] /= alpha;
        return *this;
    }
private:
    T data[3];
};

template<typename T>
Array<T,3> operator+(Array<T,3> const& a, Array<T,3> const& b) {
    return Array<T,3>(a[0]+b[0], a[1]+b[1], a[2]+b[2]);
}

template<typename T>
Array<T,3> operator+(Array<T,3> const& a, T alpha) {
    return Array<T,3>(a[0]+alpha, a[1]+alpha, a[2]+alpha);
}

template<typename T>
Array<T,3> operator+(T alpha, Array<T,3> const& a) {
    return Array<T,3>(alpha+a[0], alpha+a[1], alpha+a[2]);
}

template<typename T>
Array<T,3> operator-(Array<T,3> const& a, Array<T,3> const& b) {
    return Array<T,3>(a[0]-b[0], a[1]-b[1], a[2]-b[2]);
}

template<typename T>
Array<T,3> operator-(Array<T,3> const& a) {
    return Array<T,3>(-a[0], -a[1], -a[2]);
}

template<typename T>
Array<T,3> operator-(Array<T,3> const& a, T alpha) {
    return Array<T,3>(a[0]-alpha, a[1]-alpha, a[2]-alpha);
}

template<typename T>
Array<T,3> operator-(T alpha, Array<T,3> const& a) {
    return Array<T,3>(alpha-a[0], alpha-a[1], alpha-a[2]);
}

template<typename T>
Array<T,3> operator*(Array<T,3> const& a, Array<T,3> const& b) {
    return Array<T,3>(a[0]*b[0], a[1]*b[1], a[2]*b[2]);
}

template<typename T>
Array<T,3> operator*(Array<T,3> const& a, T alpha) {
    return Array<T,3>(a[0]*alpha, a[1]*alpha, a[2]*alpha);
}

template<typename T>
Array<T,3> operator*(T alpha, Array<T,3> const& a) {
    return Array<T,3>(alpha*a[0], alpha*a[1], alpha*a[2]);
}

template<typename T>
Array<T,3> operator/(Array<T,3> const& a, Array<T,3> const& b) {
    return Array<T,3>(a[0]/b[0], a[1]/b[1], a[2]/b[2]);
}

template<typename T>
Array<T,3> operator/(Array<T,3> const& a, T alpha) {
    return Array<T,3>(a[0]/alpha, a[1]/alpha, a[2]/alpha);
}

template<typename T>
Array<T,3> operator/(T alpha, Array<T,3> const& a) {
    return Array<T,3>(alpha/a[0], alpha/a[1], alpha/a[2]);
}


template<typename T>
class Array<T,4> {
public:
    Array() { }
    Array(T a0, T a1, T a2, T a3) {
        data[0] = a0;
        data[1] = a1;
        data[2] = a2;
        data[3] = a3;
    }
    template<typename U>
    Array(Array<U,4> const& rhs) {
        data[0] = (T) rhs[0];
        data[1] = (T) rhs[1];
        data[2] = (T) rhs[2];
        data[3] = (T) rhs[3];
    }
    template<typename U>
    Array<T,4>& operator=(Array<U,4> const& rhs) {
        data[0] = (T) rhs[0];
        data[1] = (T) rhs[1];
        data[2] = (T) rhs[2];
        data[3] = (T) rhs[3];
    }
    T& operator[](pluint index) {
        PLB_PRECONDITION(index<4);
        return data[index];
    }
    T const& operator[](pluint index) const {
        PLB_PRECONDITION(index<4);
        return data[index];
    }
    void from_cArray(T const* cArray) {
        data[0] = cArray[0];
        data[1] = cArray[1];
        data[2] = cArray[2];
        data[3] = cArray[3];
    }
    void to_cArray(T* cArray) const {
        cArray[0] = data[0];
        cArray[1] = data[1];
        cArray[2] = data[2];
        cArray[3] = data[3];
    }
    void resetToZero() {
        data[0] = T();
        data[1] = T();
        data[2] = T();
        data[3] = T();
    }
    Array<T,4>& operator += (Array<T,4> const& b) {
        data[0] += b[0];
        data[1] += b[1];
        data[2] += b[2];
        data[3] += b[3];
        return *this;
    }
    Array<T,4>& operator += (T alpha) {
        data[0] += alpha;
        data[1] += alpha;
        data[2] += alpha;
        data[3] += alpha;
        return *this;
    }
    Array<T,4>& operator -= (Array<T,4> const& b) {
        data[0] -= b[0];
        data[1] -= b[1];
        data[2] -= b[2];
        data[3] -= b[3];
        return *this;
    }
    Array<T,4>& operator -= (T alpha) {
        data[0] -= alpha;
        data[1] -= alpha;
        data[2] -= alpha;
        data[3] -= alpha;
        return *this;
    }
    Array<T,4>& operator *= (Array<T,4> const& b) {
        data[0] *= b[0];
        data[1] *= b[1];
        data[2] *= b[2];
        data[3] *= b[3];
        return *this;
    }
    Array<T,4>& operator *= (T alpha) {
        data[0] *= alpha;
        data[1] *= alpha;
        data[2] *= alpha;
        data[3] *= alpha;
        return *this;
    }
    Array<T,4>& operator /= (Array<T,4> const& b) {
        data[0] /= b[0];
        data[1] /= b[1];
        data[2] /= b[2];
        data[3] /= b[3];
        return *this;
    }
    Array<T,4>& operator /= (T alpha) {
        data[0] /= alpha;
        data[1] /= alpha;
        data[2] /= alpha;
        data[3] /= alpha;
        return *this;
    }
private:
    T data[4];
};

template<typename T>
Array<T,4> operator+(Array<T,4> const& a, Array<T,4> const& b) {
    return Array<T,4>(a[0]+b[0], a[1]+b[1], a[2]+b[2], a[3]+b[3]);
}

template<typename T>
Array<T,4> operator+(Array<T,4> const& a, T alpha) {
    return Array<T,4>(a[0]+alpha, a[1]+alpha, a[2]+alpha, a[3]+alpha);
}

template<typename T>
Array<T,4> operator+(T alpha, Array<T,4> const& a) {
    return Array<T,4>(alpha+a[0], alpha+a[1], alpha+a[2], alpha+a[3]);
}

template<typename T>
Array<T,4> operator-(Array<T,4> const& a, Array<T,4> const& b) {
    return Array<T,4>(a[0]-b[0], a[1]-b[1], a[2]-b[2], a[3]-b[3]);
}

template<typename T>
Array<T,4> operator-(Array<T,4> const& a) {
    return Array<T,4>(-a[0], -a[1], -a[2], -a[3]);
}

template<typename T>
Array<T,4> operator-(Array<T,4> const& a, T alpha) {
    return Array<T,4>(a[0]-alpha, a[1]-alpha, a[2]-alpha, a[3]-alpha);
}

template<typename T>
Array<T,4> operator-(T alpha, Array<T,4> const& a) {
    return Array<T,4>(alpha-a[0], alpha-a[1], alpha-a[2], alpha-a[3]);
}

template<typename T>
Array<T,4> operator*(Array<T,4> const& a, Array<T,4> const& b) {
    return Array<T,4>(a[0]*b[0], a[1]*b[1], a[2]*b[2], a[3]*b[3]);
}

template<typename T>
Array<T,4> operator*(Array<T,4> const& a, T alpha) {
    return Array<T,4>(a[0]*alpha, a[1]*alpha, a[2]*alpha, a[3]*alpha);
}

template<typename T>
Array<T,4> operator*(T alpha, Array<T,4> const& a) {
    return Array<T,4>(alpha*a[0], alpha*a[1], alpha*a[2], alpha*a[3]);
}

template<typename T>
Array<T,4> operator/(Array<T,4> const& a, Array<T,4> const& b) {
    return Array<T,4>(a[0]/b[0], a[1]/b[1], a[2]/b[2], a[3]/b[3]);
}

template<typename T>
Array<T,4> operator/(Array<T,4> const& a, T alpha) {
    return Array<T,4>(a[0]/alpha, a[1]/alpha, a[2]/alpha, a[3]/alpha);
}

template<typename T>
Array<T,4> operator/(T alpha, Array<T,4> const& a) {
    return Array<T,4>(alpha/a[0], alpha/a[1], alpha/a[2], alpha/a[3]);
}

} // end namespace plb

#endif