From: Kahina <kahina@kahina-VPCEH3K1E.(none)>
Date: Thu, 5 Nov 2015 02:35:40 +0000 (+0100)
Subject: Figure 4
X-Git-Url: https://bilbo.iut-bm.univ-fcomte.fr/and/gitweb/kahina_paper1.git/commitdiff_plain/bbbeb47ad22f51afe096a43c96a0130e92e19c30

Figure 4
---

diff --git a/figures/EA_DK.pdf b/figures/EA_DK.pdf
index 665aaa4..575a652 100644
Binary files a/figures/EA_DK.pdf and b/figures/EA_DK.pdf differ
diff --git a/figures/EA_DK.plot b/figures/EA_DK.plot
index 7a19f02..1030dda 100644
--- a/figures/EA_DK.plot
+++ b/figures/EA_DK.plot
@@ -15,6 +15,7 @@ set logscale x
 set logscale y
 
 #set key on outside left bmargin
+set key on inside left top
 set style line 1 lc rgb '#000c16' lt 1 lw 2 pt 4 ps 1.5   # --- blue
 set style line 2 lc rgb '#000c16' lt 1 lw 2 pt 5 ps 1.5   # --- red
 set style line 3 lc rgb '#000c16' lt 1 lw 2 pt 6 ps 1.5   # --- red
diff --git a/paper.tex b/paper.tex
index c608935..abc8b8d 100644
--- a/paper.tex
+++ b/paper.tex
@@ -719,7 +719,7 @@ In Figure~\ref{fig:01}, we report respectively the execution time of the Ehrlich
 
 \subsection{Influence of the number of threads on the execution times of different polynomials (sparse and full)}
 To optimize the performances of an algorithm on a GPU, it is necessary to maximize the use of cores GPU (maximize the number of threads executed in parallel) and to optimize the use of the various memoirs GPU. In fact, it is interesting to see the influence of the number of threads per block on the execution time of Ehrlich-Aberth algorithm. 
-For that, we notice that the maximum number of threads per block for the Nvidia Tesla K40 GPU is 1024, so we varied the number of threads per block from 8 to 1,024. We took into account the execution time for both sparse and full of 10 different polynomials of size 50,000 and 10 different polynomials of size 500,000 degrees.
+For that, we notice that the maximum number of threads per block for the Nvidia Tesla K40 GPU is 1,024, so we varied the number of threads per block from 8 to 1,024. We took into account the execution time for both sparse and full of 10 different polynomials of size 50,000 and 10 different polynomials of size 500,000 degrees.
 
 \begin{figure}[htbp]
 \centering
@@ -736,7 +736,7 @@ In this experiment we report the performance of the exp-log solution described i
 \begin{figure}[htbp]
 \centering
   \includegraphics[width=0.8\textwidth]{figures/sparse_full_explog}
-\caption{The impact of exp.log solution to compute very high degrees of  polynomial.}
+\caption{The impact of exp-log solution to compute very high degrees of  polynomial.}
 \label{fig:03}
 \end{figure}
 
@@ -747,13 +747,13 @@ execution time of the Ehrlich-Aberth method without this solution,
 with full and sparse polynomials degrees. We can see that the
 execution times for both algorithms are the same with full polynomials
 degrees less than 4,000 and sparse polynomials less than 150,000. We
-also clearly show that the classical version (without log-exp) of
+also clearly show that the classical version (without exp-log) of
 Ehrlich-Aberth algorithm do not converge after these degree with
 sparse and full polynomials. In counterpart, the new version of
 Ehrlich-Aberth algorithm with the exp-log solution can solve very
 high degree polynomials.
 
-%in fact, when the modulus of the roots are up than \textit{R} given in ~\ref{R},this exceed the limited number in the mantissa of floating points representations and can not compute the iterative function given in ~\ref{eq:Aberth-H-GS} to obtain the root solution, who justify the divergence of the classical Ehrlich-Aberth algorithm. However, applying log.exp solution given in ~\ref{sec2} took into account the limit of floating using the iterative function in(Eq.~\ref{Log_H1},Eq.~\ref{Log_H2} and allows to solve a very large polynomials degrees . 
+%in fact, when the modulus of the roots are up than \textit{R} given in ~\ref{R},this exceed the limited number in the mantissa of floating points representations and can not compute the iterative function given in ~\ref{eq:Aberth-H-GS} to obtain the root solution, who justify the divergence of the classical Ehrlich-Aberth algorithm. However, applying exp-log solution given in ~\ref{sec2} took into account the limit of floating using the iterative function in(Eq.~\ref{Log_H1},Eq.~\ref{Log_H2} and allows to solve a very large polynomials degrees . 
 
 
 
@@ -770,13 +770,6 @@ methods on GPU. We took into account the execution times, the number of iteratio
 \label{fig:04}
 \end{figure}
 
-\begin{figure}[htbp]
-\centering
-  \includegraphics[width=0.8\textwidth]{figures/EA_DK1}
-\caption{Execution times of the  Durand-Kerner and the Ehrlich-Aberth methods on GPU}
-\label{fig:0}
-\end{figure}
-
 Figure~\ref{fig:04} shows the execution times of both methods with
 sparse polynomial degrees ranging from 1,000 to 1,000,000. We can see
 that the Ehrlich-Aberth algorithm is faster than Durand-Kerner