/**
 * classe MPIArray définie par sa taille et ses données
 * qui sont allouée sous forme d'un tableau C
 */
template <class T>
class MPIArray
{
public:
    // taille du tableau en nombre d'éléments
    int _size;
    // pointeur sur les éléments du tableau
    T *_elements;

    /**
     * Constructeur par défaut qui définit un tableau
     * de taille 0
     */
    MPIArray()
    {
        // écrire le code
    }

    /**
     * Constructeur avec taille du tableau en paramètre
     */
    MPIArray(T size) : _size(size)
    {
        // écrire le code
    }

    /**
     * Destructeur qui libère la mémoire
     */
    ~MPIArray()
    {
        // écrire le code
    }

    /**
     * Affichage des éléments qui composent le tableau
     */
    friend ostream &operator<<(ostream &out, MPIArray<T> &obj)
    {
        out << "[";
        for (int i = 0; i < obj._size; ++i)
        {
            out << obj._elements[i] << " ";
        }
        out << "]";
        return out;
    }

    /**
     * Redimensionnement du tableau : on crée un tableau de taille new_size
     * et on garde les min(_size, new_size) éléments
     */
    void resize(int new_size)
    {
        // écrire le code
    }

    /**
     * Envoi du tableau (taille + éléments) au processus d'identifiant to_id
     */
    void send_to(int to_id)
    {
        // écrire le code
    }

    /**
     * Réception du tableau (taille + éléments) envoyé par le processus
     * d'identifiant from_id
     */
    void recv_from(int from_id)
    {
        // écrire le code
    }

    /**
     * Retourne la taille du tableau
     */
    int size()
    {
        return _size;
    }

    /**
     * Retourne le pointeur vers les éléments
     */
    T *operator()()
    {
        return _elements;
    }

    /**
     * Retourne le n-ième élément
     */
    T &operator[](int n)
    {
        // écrire le code
    }

    /**
     * Remplissage du tableau avec des valeurs croissantes
     */
    void iota()
    {
        for (int i = 0; i < _size; ++i)
        {
            _elements[i] = i;
        }
    }

    /**
     * Réalise le découpage du tableau en nbr_cpus parties équitables
     * 1) envoi aux nbr_cpus-1 escalves de leur partie du tableau
     * 2) redimensionnement du tableau pour le master
     */
    void scatter(int cpu_id, int nbr_cpus)
    {
        // écrire le code
    }

    /**
     * Création d'un tableau à partir du tableau du master et des
     * tableaux des nbr_cpus-1 esclaves
     */
    void gather(int cpu_id, int nbr_cpus)
    {
        // écrire le code
    }
};