MAJ de algo 1 & algo 2

[kahina_paper1.git] / paper.tex

diff --git a/paper.tex b/paper.tex
index 7ef63458a6462d561214345c3ed15b6de3810c3a..dde98e9a3813b6f5ea0b97a825bf7d5d1de2d976 100644 (file)
--- a/paper.tex
+++ b/paper.tex
@@ -365,6 +365,7 @@ Q(z^{k}_{i})=\exp\left( \ln (p(z^{k}_{i}))-\ln(p'(z^{k}_{i}))+\ln \left(
 \end{equation}
 
 This solution is applied when the root except the circle unit, represented by the radius $R$ evaluated in C language as:
+
 \begin{verbatim}
 R = exp(log(DBL_MAX)/(2*n) );
 \end{verbatim} 
@@ -582,7 +583,7 @@ Algorithm~\ref{alg2-cuda} shows a sketch of the Ehrlich-Aberth algorithm using C
 \caption{CUDA Algorithm to find roots with the Ehrlich-Aberth method}
 
 \KwIn{$Z^{0}$ (Initial root's vector), $\varepsilon$ (error tolerance
-  threshold), P(Polynomial to solve), Pu (the derivative of P), $n$ (Polynomial's degrees),$\Delta z_{max}$ (maximum value of stop condition)}
+  threshold), P(Polynomial to solve), Pu (the derivative of P), $n$ (Polynomial's degrees), $\Delta z_{max}$ (maximum value of stop condition)}
 
 \KwOut {$Z$ (The solution root's vector), $ZPrec$ (the previous solution root's vector)}
 
@@ -591,14 +592,14 @@ Algorithm~\ref{alg2-cuda} shows a sketch of the Ehrlich-Aberth algorithm using C
 Initialization of the of P\;
 Initialization of the of Pu\;
 Initialization of the solution vector $Z^{0}$\;
-Allocate and copy initial data to the GPU global memory ($d\_Z,d\_ZPrec,d\_P,d\_Pu$)\;
+Allocate and copy initial data to the GPU global memory\;
 k=0\;
 \While {$\Delta z_{max} > \epsilon$}{
  Let $\Delta z_{max}=0$\;
-$ kernel\_save(d\_ZPrec,d\_Z)$\;
+$ kernel\_save(ZPrec,Z)$\;
 k=k+1\;
-$ kernel\_update(d\_Z,d\_P,d\_Pu)$\;
-$kernel\_testConverge(\Delta z_{max},d\_Z,d\_ZPrec)$\;
+$ kernel\_update(Z,P,Pu)$\;
+$kernel\_testConverge(\Delta z_{max},Z,ZPrec)$\;
 
 }
 Copy results from GPU memory to CPU memory\;
@@ -618,10 +619,10 @@ exponential logarithm algorithm.
 %\LinesNumbered
 \caption{Kernel update}
 
-\eIf{$(\left|d\_Z\right|<= R)$}{
-$kernel\_update((d\_Z,d\_P,d\_Pu)$\;}
+\eIf{$(\left|Z\right|<= R)$}{
+$kernel\_update((Z,P,Pu)$\;}
 {
-$kernel\_update\_ExpoLog((d\_Z,d\_P,\_Pu))$\;
+$kernel\_update\_ExpoLog((Z,P,Pu))$\;
 }
 \end{algorithm}
 
@@ -731,20 +732,17 @@ For that, we notice that the maximum number of threads per block for the Nvidia
 
 The figure 2 show that, the best execution time for both sparse and full polynomial are given when the threads number varies between 64 and 256 threads per bloc. We notice that with small polynomials the best number of threads per block is 64, Whereas, the large polynomials the best number of threads per block is 256. However,In the following experiments we specify that the number of thread by block is 256.
 
-\subsection{The impact of exp-log solution to compute very high degrees of  polynomial}
+\subsection{The impact of exp.log solution to compute very high degrees of  polynomial}
 
-<<<<<<< HEAD
 In this experiment we report the performance of exp-log solution described in Section~\ref{sec2} to compute very high degrees polynomials.   
-=======
-In this experiment we report the performance of log.exp solution describe in ~\ref{sec2} to compute very high degrees polynomials.   
->>>>>>> 7f2978c0d220516decb65faf2b8ba2da34df8db2
 \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}
 
+
 Figure~\ref{fig:03} shows a comparison between the execution time of
 the Ehrlich-Aberth algorithm using the exp.log solution and the
 execution time of the Ehrlich-Aberth algorithm without this solution,
@@ -761,6 +759,7 @@ high degree polynomials.
 
 
 
+
 \subsection{Comparison of the Durand-Kerner and the Ehrlich-Aberth methods}
 
 In this part, we  compare the Durand-Kerner and the Ehrlich-Aberth