+This method contains 4 steps. The first step consists in the initializing the polynomial. The second step initializes the solution vector $Z$ using the Guggenheimer method~\cite{Gugg86} to ensure that initial roots are all distinct from each other. In step 3, the iterative function based on the Newton's method~\cite{newt70} and Weiestrass operator~\cite{Weierstrass03} is applied. In our case, the Ehrlich-Aberth is applied as in~(\ref{Eq:EA1}). Iterations of the Ehrlich-Aberth method will converge to the roots of the considered polynomial. In order to stop the iterative function, a stop condition is applied, this is the 4th step. This condition checks that all the root modules are lower than a fixed value $\epsilon$.
+
+\begin{equation}
+\label{eq:Aberth-Conv-Cond}
+\forall i\in[1,n],~\vert\frac{z_i^k-z_i^{k-1}}{z_i^k}\vert<\epsilon
+\end{equation}
+
+\subsection{Improving Ehrlich-Aberth method}
+With high degree polynomials, the Ehrlich-Aberth method suffers from floating point overflows due to the mantissa of floating points representations. This induces errors in the computation of $p(z)$ when $z$ is large.
+
+%Experimentally, it is very difficult to solve polynomials with the Ehrlich-Aberth method and have roots which except the circle of unit, represented by the radius $r$ evaluated as:
+
+%\begin{equation}
+%\label{R.EL}
+%R = exp(log(DBL\_MAX)/(2*n) );
+%\end{equation}
+
+
+
+% where \verb=DBL_MAX= stands for the maximum representable \verb=double= value.
+
+In order to solve this problem, we propose to modify the iterative
+function by using the logarithm and the exponential of a complex and
+we propose a new version of the Ehrlich-Aberth method. This method
+allows us to exceed the computation of the polynomials of degree
+100,000 and to reach a degree up to more than 1,000,000. The reformulation of the iteration~(\ref{Eq:EA1}) of the Ehrlich-Aberth method with exponential and logarithm is defined as follows, for $i=1,\dots,n$:
+
+\begin{equation}
+\label{Log_H2}
+z^{k+1}_i = z_i^k - \exp(\ln(p(z_i^k)) - \ln(p'(z^k_i)) - \ln(1-Q(z^k_i))),
+\end{equation}
+
+where:
+
+\begin{equation}
+\label{Log_H1}
+Q(z^k_i) = \exp(\ln(p(z^k_i)) - \ln(p'(z^k_i)) + \ln(\sum_{i\neq j}^n\frac{1}{z^k_i-z^k_j})).
+\end{equation}
+
+
+%We propose to use the logarithm and the exponential of a complex in order to compute the power at a high exponent.
+Using the logarithm and the exponential operators, we can replace any multiplications and divisions with additions and subtractions. Consequently, computations manipulate lower values in absolute values~\cite{Karimall98}.
+
+%This problem was discussed earlier in~\cite{Karimall98} for the Durand-Kerner method. The authors
+%propose to use the logarithm and the exponential of a complex in order to compute the power at a high exponent. Using the logarithm and the exponential operators, we can replace any multiplications and divisions with additions and subtractions. Consequently, computations manipulate lower absolute values and the roots for large polynomial degrees can be looked for successfully~\cite{Karimall98}.
+
+\subsection{The Ehrlich-Aberth parallel implementation on CUDA}
+%We introduced three paradigms of parallel programming.
+
+Our objective consists in implementing a root finding polynomial
+algorithm on multiple GPUs. To this end, it is primordial to know how
+to manage CUDA contexts of different GPUs. A direct method for
+controlling the various GPUs is to use as many threads or processes as
+GPU devices. We can choose the GPU index based on the identifier of
+OpenMP thread or the rank of the MPI process. Both approaches will be
+investigated. \LZK{Répétition! Le même texte est déjà écrit comme
+ intro dans la section II. Sinon ici on parle seulement de
+ l'implémentation cuda sans mpi et openmp! \RC{Je suis d'accord à
+ revoir après, quand les 2 parties suivantes seront plus stables}}
+
+
+
+
+Like any parallel code, a GPU parallel implementation first requires to determine the sequential code and the data-parallel operations of a algorithm. In fact, all the operations that are easy to execute in parallel must be made by the GPU to accelerate the execution, like the steps 3 and 4. On the other hand, all the sequential operations and the operations that have data dependencies between CUDA threads or recursive computations must be executed by only one CUDA thread or a CPU thread (the steps 1 and 2).\LZK{La méthode est déjà mal présentée, dans ce cas c'est encore plus difficile de comprendre que représentent ces différentes étapes!} Initially, we specify the organization of parallel threads by specifying the dimension of the grid \verb+Dimgrid+, the number of blocks per grid \verb+DimBlock+ and the number of threads per block.
+
+The code is organized as kernels which are parts of code that are run on GPU devices. For step 3, there are two kernels, the first is named \textit{save} is used to save vector $Z^{K-1}$ and the second one is
+named \textit{update} and is used to update the $Z^{K}$ vector. For
+step 4, a kernel tests the convergence of the method. In order to
+compute the function H, we have two possibilities: either to use the
+Jacobi mode, or the Gauss-Seidel mode of iterating which uses the most
+recent computed roots. It is well known that the Gauss-Seidel mode
+converges more quickly. So, we use Gauss-Seidel iterations. To
+parallelize the code, we create kernels and many functions to be
+executed on the GPU for all the operations dealing with the
+computation on complex numbers and the evaluation of the
+polynomials. As said previously, we manage both functions of
+evaluation: the normal method, based on the method of
+Horner and the method based on the logarithm of the polynomial. All
+these methods were rather long to implement, as the development of
+corresponding kernels with CUDA is longer than on a CPU host. This
+comes in particular from the fact that it is very difficult to debug
+CUDA running threads like threads on a CPU host. In the following
+paragraph Algorithm~\ref{alg1-cuda} shows the GPU parallel
+implementation of Ehrlich-Aberth method.
+\LZK{Vaut mieux expliquer l'implémentation en faisant référence à l'algo séquentiel que de parler des différentes steps.}
+
+%\begin{algorithm}[htpb]
+%\label{alg1-cuda}
+%\LinesNumbered
+%\SetAlgoNoLine
+%\caption{CUDA Algorithm to find polynomial roots with the Ehrlich-Aberth method}
+%\KwIn{$Z^{0}$ (Initial vector of roots), $\epsilon$ (Error tolerance threshold), P (Polynomial to solve), Pu (Derivative of P), $n$ (Polynomial degree), $\Delta z_{max}$ (Maximum value of stop condition)}
+%\KwOut{$Z$ (Solution vector of roots)}
